#lang = zh_tw 

#find_links = http://www.pylonshq.com/download/

    main = vigiboard.config.middleware:make_app

# -*- coding: utf-8 -*-

"""The vigiboard package"""

# -*- coding: utf-8 -*-

# -*- coding: utf-8 -*-

"""

Global configuration file for TG2-specific settings in vigiboard.

This file complements development/deployment.ini.

Please note that **all the argument values are strings**. If you want to

convert them into boolean, for example, you should use the

:func:`paste.deploy.converters.asbool` function, as in::

    from paste.deploy.converters import asbool

    setting = asbool(global_conf.get('the_setting'))

"""

from tg.configuration import AppConfig

import vigiboard

from vigiboard import model

from vigiboard.lib import app_globals, helpers 

base_config = AppConfig()

base_config.renderers = []

base_config.package = vigiboard

#Set the default renderer

base_config.default_renderer = 'genshi'

base_config.renderers.append('genshi')

# if you want raw speed and have installed chameleon.genshi

# you should try to use this renderer instead.

# warning: for the moment chameleon does not handle i18n translations

#base_config.renderers.append('chameleon_genshi')

#Configure the base SQLALchemy Setup

base_config.use_sqlalchemy = True

base_config.model = vigiboard.model

base_config.DBSession = vigiboard.model.DBSession

# Configure the authentication backend

base_config.auth_backend = 'sqlalchemy'

base_config.sa_auth.dbsession = model.DBSession

# what is the class you want to use to search for users in the database

base_config.sa_auth.user_class = model.User

# what is the class you want to use to search for groups in the database

base_config.sa_auth.group_class = model.Group

# what is the class you want to use to search for permissions in the database

base_config.sa_auth.permission_class = model.Permission

# override this if you would like to provide a different who plugin for

# managing login and logout of your application

base_config.sa_auth.form_plugin = None

# You may optionally define a page where you want users to be redirected to

# on login:

base_config.sa_auth.post_login_url = '/post_login'

# You may optionally define a page where you want users to be redirected to

# on logout:

base_config.sa_auth.post_logout_url = '/post_logout'

#

# vigiboard - TurboGears configuration

#

# The %(here)s variable will be replaced with the parent directory of this file

#

[DEFAULT]

# WARGING == If debug is not set to false, you'll get the interactive

# debugger on production, which is a huge security hole. 

debug = false

email_to = you@yourdomain.com

smtp_server = localhost

error_email_from = paste@localhost

[server:main]

use = egg:Paste#http

host = 0.0.0.0

port = 8080

[app:main]

use = egg:vigiboard

full_stack = true

cache_dir = %(here)s/data

beaker.session.key = vigiboard

beaker.session.secret = ${app_instance_secret}

app_instance_uuid = ${app_instance_uuid}

# If you'd like to fine-tune the individual locations of the cache data dirs

# for the Cache data, or the Session saves, un-comment the desired settings

# here:

#beaker.cache.data_dir = %(here)s/data/cache

#beaker.session.data_dir = %(here)s/data/sessions

# Specify the database for SQLAlchemy to use via

# turbogears.database

# %(here) may include a ':' character on Windows environments; this can

# invalidate the URI when specifying a SQLite db via path name

sqlalchemy.url = sqlite:///%(here)s/somedb.db

sqlalchemy.echo = False

# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*

# Debug mode will enable the interactive debugging tool, allowing ANYONE to

# execute malicious code after an exception is raised.

#set debug = false

# Logging configuration

# Add additional loggers, handlers, formatters here

# Uses python's logging config file format

# http://docs.python.org/lib/logging-config-fileformat.html

[loggers]

keys = root, vigiboard, sqlalchemy, auth

[handlers]

keys = console

[formatters]

keys = generic

# If you create additional loggers, add them as a key to [loggers]

[logger_root]

level = INFO

handlers = console

[logger_vigiboard]

level = INFO

handlers =

qualname = vigiboard

[logger_sqlalchemy]

level = WARN

handlers =

qualname = sqlalchemy.engine

# "level = INFO" logs SQL queries.

# "level = DEBUG" logs SQL queries and results.

# "level = WARN" logs neither.  (Recommended for production systems.)

# A logger for authentication, identification and authorization -- this is

# repoze.who and repoze.what:

[logger_auth]

level = WARN

handlers = 

qualname = auth

# If you create additional handlers, add them as a key to [handlers]

[handler_console]

class = StreamHandler

args = (sys.stderr,)

level = NOTSET

formatter = generic

# If you create additional formatters, add them as a key to [formatters]

[formatter_generic]

format = %(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s

datefmt = %H:%M:%S

# -*- coding: utf-8 -*-

"""WSGI environment setup for vigiboard."""

from vigiboard.config.app_cfg import base_config

__all__ = ['load_environment']

#Use base_config to setup the environment loader function

load_environment = base_config.make_load_environment()

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4:

"""WSGI middleware initialization for the vigiboard application."""

from vigiboard.config.app_cfg import base_config

from vigiboard.config.environment import load_environment

from vigiboard.config.vigilo_conf import vigilo_mods

__all__ = ['make_app']

# Use base_config to setup the necessary PasteDeploy application factory. 

# make_base_app will wrap the TG2 app with all the middleware it needs. 

make_base_app = base_config.setup_tg_wsgi_app(load_environment)

def make_app(global_conf, full_stack=True, **app_conf):

    """

    Set vigiboard up with the settings found in the PasteDeploy configuration

    file used.

    :param global_conf: The global settings for vigiboard (those

        defined under the ``[DEFAULT]`` section).

    :type global_conf: dict

    :param full_stack: Should the whole TG2 stack be set up?

    :type full_stack: str or bool

    :return: The vigiboard application with all the relevant middleware

        loaded.

    This is the PasteDeploy factory for the vigiboard application.

    ``app_conf`` contains all the application-specific settings (those defined

    under ``[app:main]``.

    """

    # Petit hack permettant d'importer la configuration de vigiboard

    for mod in vigilo_mods :

        myconf = __import__(

            'vigiboard.config.vigilo_conf.' + mod ,globals(), locals(), [mod + '_config'],-1)

        myconf = getattr(myconf,mod + '_config')

        for conf in myconf:

            app_conf[conf] = myconf[conf]

    app_conf['vigilo_mods'] = vigilo_mods

    app = make_base_app(global_conf, full_stack=True, **app_conf)

    # Wrap your base TurboGears 2 application with custom middleware here

    return app

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4:

vigilo_mods = [

                    'vigicore',

		            'vigiboard'

	          ]

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4:

"""Configuration de Vigiboard."""

vigiboard_config = {

    # Affichage, lien disponibles dans la fenêtre de détail d'un évènement

    'vigiboard_links.nagios' : 'http://example1.com/%(idevent)d',

    'vigiboard_links.metrology' : 'http://example2.com/%(idevent)d',

    'vigiboard_links.security' : 'http://example3.com/%(idevent)d',

    'vigiboard_links.servicetype' : 'http://example4.com/%(idevent)d',

    # Nombre d'évènments par pages

    'vigiboard_item_per_page' : '15',

    'vigiboard_plugins' : [

        [ 'shn' , 'PluginSHN' ]

        ]

}

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4:

"""Configuration de VigiCore."""

vigicore_config = {

        'vigicore_bdd.basename' : ''

}

# -*- coding: utf-8 -*-

"""Controllers for the vigiboard application."""

# -*- coding: utf-8 -*-

"""Sample controller module"""

# turbogears imports

from tg import expose

#from tg import redirect, validate, flash

# third party imports

#from pylons.i18n import ugettext as _

#from repoze.what import predicates

# project specific imports

from vigiboard.lib.base import BaseController

#from vigiboard.model import DBSession, metadata

class SampleController(BaseController):

    #Uncomment this line if your controller requires an authenticated user

    #allow_only = authorize.not_anonymous()

    @expose('vigiboard.templates.index')

    def index(self):

        return dict(page='index')

# -*- coding: utf-8 -*-

"""Error controller"""

from tg import request, expose

__all__ = ['ErrorController']

class ErrorController(object):

    """

    Generates error documents as and when they are required.

    The ErrorDocuments middleware forwards to ErrorController when error

    related status codes are returned from the application.

    This behaviour can be altered by changing the parameters to the

    ErrorDocuments middleware in your config/middleware.py file.

    """

    @expose('vigiboard.templates.error')

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

        """Render the error document"""

        resp = request.environ.get('pylons.original_response')

        default_message = ("<p>We're sorry but we weren't able to process "

                           " this request.</p>")

        values = dict(prefix=request.environ.get('SCRIPT_NAME', ''),

                      code=request.params.get('code', resp.status_int),

                      message=request.params.get('message', default_message))

        return values

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4: 

"""Main Controller"""

from tg import expose, flash, require, url, request, redirect, config

from pylons.i18n import ugettext as _, lazy_ugettext as l_

from catwalk.tg2 import Catwalk

from repoze.what import predicates

from vigiboard.lib.base import BaseController

from vigiboard.model import DBSession 

from vigiboard.controllers.error import ErrorController

from vigiboard import model

from vigiboard.controllers.secure import SecureController

__all__ = ['RootController']

class RootController(BaseController):

    """

    The root controller for the vigiboard application.

    All the other controllers and WSGI applications should be mounted on this

    controller. For example::

        panel = ControlPanelController()

        another_app = AnotherWSGIApplication()

    Keep in mind that WSGI applications shouldn't be mounted directly: They

    must be wrapped around with :class:`tg.controllers.WSGIAppController`.

    """

    secc = SecureController()

    admin = Catwalk(model, DBSession)

    error = ErrorController()

    # on charge les controleurs souhaité en dynamique

    def __init__(self) :

        super(RootController,self).__init__()

        for mod in config['vigilo_mods']:

            try :

                mymod = __import__(

                    'vigiboard.controllers.' + mod + '_ctl',globals(), locals(), [mod + 'Controller'],-1)

                setattr(self,mod,getattr(mymod,mod + 'Controller')())

            except:

                pass

    @expose('vigiboard.templates.index')

    def index(self):

        """Handle the front-page."""

        return dict(page='index')

    @expose('vigiboard.templates.about')

    def about(self):

        """Handle the 'about' page."""

        return dict(page='about')

    @expose('vigiboard.templates.authentication')

    def auth(self):

        """Display some information about auth* on this application."""

        return dict(page='auth')

    @expose('vigiboard.templates.index')

    @require(predicates.has_permission('manage', msg=l_('Only for managers')))

    def manage_permission_only(self, **kw):

        """Illustrate how a page for managers only works."""

        return dict(page='managers stuff')

    @expose('vigiboard.templates.index')

    @require(predicates.is_user('editor', msg=l_('Only for the editor')))

    def editor_user_only(self, **kw):

        """Illustrate how a page exclusive for the editor works."""

        return dict(page='editor stuff')

    @expose('vigiboard.templates.login')

    def login(self, came_from=url('/')):

        """Start the user login."""

        login_counter = request.environ['repoze.who.logins']

        if login_counter > 0:

            flash(_('Wrong credentials'), 'warning')

        return dict(page='login', login_counter=str(login_counter),

                    came_from=came_from)

    @expose()

    def post_login(self, came_from=url('/')):

        """

        Redirect the user to the initially requested page on successful

        authentication or redirect her back to the login page if login failed.

        """

        if not request.identity:

            login_counter = request.environ['repoze.who.logins'] + 1

            redirect(url('/login', came_from=came_from, __logins=login_counter))

        userid = request.identity['repoze.who.userid']

        flash(_('Welcome back, %s!') % userid)

        redirect(came_from)

    @expose()

    def post_logout(self, came_from=url('/')):

        """

        Redirect the user to the initially requested page on logout and say

        goodbye as well.

        """

        flash(_('We hope to see you soon!'))

        redirect(came_from)

# -*- coding: utf-8 -*-

"""Sample controller with all its actions protected."""

from tg import expose, flash

from pylons.i18n import ugettext as _, lazy_ugettext as l_

from repoze.what.predicates import has_permission

#from dbsprockets.dbmechanic.frameworks.tg2 import DBMechanic

#from dbsprockets.saprovider import SAProvider

from vigiboard.lib.base import BaseController

#from vigiboard.model import DBSession, metadata

__all__ = ['SecureController']

class SecureController(BaseController):

    """Sample controller-wide authorization"""

    # The predicate that must be met for all the actions in this controller:

    allow_only = has_permission('manage',

                                msg=l_('Only for people with the "manage" permission'))

    @expose('vigiboard.templates.index')

    def index(self):

        """Let the user know that's visiting a protected controller."""

        flash(_("Secure Controller here"))

        return dict(page='index')

    @expose('vigiboard.templates.index')

    def some_where(self):

        """Let the user know that this action is protected too."""

        return dict(page='some_where')

# -*- coding: utf-8 -*-

"""Fallback controller."""

from vigiboard.lib.base import BaseController

__all__ = ['TemplateController']

class TemplateController(BaseController):

    """

    The fallback controller for vigiboard.

    By default, the final controller tried to fulfill the request

    when no other routes match. It may be used to display a template

    when all else fails, e.g.::

        def view(self, url):

            return render('/%s' % url)

    Or if you're using Mako and want to explicitly send a 404 (Not

    Found) response code when the requested template doesn't exist::

        import mako.exceptions

        def view(self, url):

            try:

                return render('/%s' % url)

            except mako.exceptions.TopLevelLookupException:

                abort(404)

    """

    def view(self, url):

        """Abort the request with a 404 HTTP status code."""

        abort(404)

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4:

"""Fonctions utiles en rapport avec l'utilisateur"""

from vigiboard.model import DBSession, Permission, Groups, GroupPermissions

from sets import Set

import tg 

def get_user_groups():

    """

    Permet de connaître l'ensemble des groups d'hôte et de service de vigiboard

    auquel l'utilisateur appartient

    @return: Liste des groups

    """

    # Requête permettant d'obtenir les groups directs de l'utilisateur

    groups = DBSession.query(Groups.name).join(

        ( GroupPermissions , Groups.name == GroupPermissions.groupname ),

        ( Permission ,

            Permission.permission_id == GroupPermissions.idpermission )

        ).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([])

        for i in groups :

            tmp.add(i.name)

            lst_grp.add(i.name)

        lst_tmp = tmp

    return lst_grp

"""

Module contenant le controller ainsi que la classe

permettant l'affichage du Vigiboard

"""

from vigiboard.controllers.vigiboard_ctl.vigiboardrequest import \

		VigiboardRequest

from vigiboard.controllers.vigiboard_ctl.vigiboard_ctl import \

		vigiboardController

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4: 

"""Vigiboard Controller"""

import tg

from tg import expose, flash, require, request, redirect, \

                validate, tmpl_context

from tw.forms import validators 

from pylons.i18n import ugettext as _

from sqlalchemy import sql, asc

from vigiboard.lib.base import TGController

from vigiboard.model import DBSession

from vigiboard.model import ServiceHautNiveau, HostGroups, \

        Events, EventHistory

from repoze.what.predicates import Any, not_anonymous

from vigiboard.widgets.edit_event import edit_event_status_options

from vigiboard.controllers.userutils import get_user_groups

from vigiboard.controllers.vigiboard_ctl.vigiboardrequest import \

        VigiboardRequest

__all__ = ['VigiboardController']

class vigiboardController(TGController):

    """

    Le controller général de vigiboard

    """

    @expose()

    def process_form_errors (self, *argv, **kwargv):

        """

        Gestion des erreurs de validation : On affiche les erreurs

        puis on redirige vers la dernière page accédée.

        """

        flash(tmpl_context.form_errors, 'error')

        if request.environ.get('HTTP_REFERER') :

            redirect(request.environ.get('HTTP_REFERER'

                ).split(request.environ.get('HTTP_HOST'))[1])

        else :

            redirect('/')

    @validate(validators={'page':validators.Int(not_empty=False)},

            error_handler=process_form_errors)

    @expose('vigiboard.templates.vigiboard')

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

    def default(self, page = 1, host = None, service = None, output = None,

            trouble_ticket=None):

        """

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

        defaut), la liste des évènements, rangé par ordre de prise en compte puis de sévérité.

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

        @param page: numéro de la page souhaité, commence à 1

        @param host: Si l'utilisateur souhaite sélectionner seulement certains

                     évènments suivant leur hôte, il peut placer une expression

                     ici en suivant la structure du LIKE en SQL

        @param service: Idem que host mais sur les services

        @param output: Idem que host mais sur le text explicatif

        @param trouble_ticket: Idem que host mais sur les tickets attribués

        """

        if page < 1 :

            page = 1

        events = VigiboardRequest()

        # Application des filtres si nécessaire

        if host :

            events.add_filter(Events.hostname.like('%%%s%%' % host))

        if service :

            events.add_filter(Events.servicename.like('%%%s%%' % service))

        if output :

            events.add_filter(Events.output.like('%%%s%%' % output))

        if trouble_ticket :

            events.add_filter(Events.trouble_ticket.like(

                '%%%s%%' % trouble_ticket))

        # Calcul des éléments à afficher et du nombre de pages possibles

        total_row = events.num_rows()

        item_per_page = int(tg.config['vigiboard_item_per_page'])

        if total_row <= item_per_page * (page-1) :

            page = 1

        id_first_row = item_per_page * (page-1)

        id_last_row = min(id_first_row + item_per_page, total_row)

        events.format_events(id_first_row, id_last_row)

        events.generate_tmpl_context() 

        return dict(

               events = events.events,

               id_first_row = id_first_row + 1,

               id_last_row = id_last_row,

               total_row = total_row,

               pages = range(1, (total_row / item_per_page) + 2),

               page = page,

               event_edit_status_options = edit_event_status_options,

               history = [],

               hist_error = False

            )

    @validate(validators={'idevent':validators.Int(not_empty=True)},

            error_handler=process_form_errors)

    @expose('json')

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

    def history_dialog (self, idevent) :

        """

        JSon renvoyant les éléments pour l'affichage de la fenêtre de dialogue

        contenant des liens internes et externes.

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

        @param id: identifiant de l'évènement

        """

        # Obtention de données sur l'évènement et sur son historique

        events = DBSession.query(Events.severity, Events.idevent,

                        Events.hostname, Events.servicename

                 ).join(( HostGroups , Events.hostname == HostGroups.hostname )

                 ).filter(HostGroups.groupname.in_(get_user_groups())

                 ).filter(Events.idevent == idevent)[0]

        initial_state = DBSession.query(EventHistory

                 ).filter(EventHistory.idevent == idevent

                 ).order_by(asc(EventHistory.timestamp)

                 ).order_by(asc(EventHistory.type_action))

        if initial_state.count() > 0 :

            initial_state = initial_state[0].value

        else :

            initial_state = 0

        severity = { 0: _('None'), 1: _('OK'), 2: _('Suppressed'),

                3: _('Initial'), 4: _('Maintenance'), 5: _('Minor'),

                6: _('Major'), 7: _('Critical') }

        return dict(

                initial_state = severity[int(initial_state)],

                current_state = severity[events.severity],

                idevent = events.idevent,

                host = events.hostname,

                service = events.servicename,

                nagios_link = tg.config['vigiboard_links.nagios'] % \

                        {'idevent': events.idevent},

                metrology_link = tg.config['vigiboard_links.metrology'] % \

                        {'idevent': events.idevent},

                security_link = tg.config['vigiboard_links.security'] % \

                        {'idevent': events.idevent},

                servicetype_link = tg.config['vigiboard_links.servicetype'] % \

                        {'idevent': events.idevent}

            )

    @validate(validators={'idevent':validators.Int(not_empty=True)},

            error_handler=process_form_errors)

    @expose('vigiboard.templates.vigiboard')

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

    def event(self, idevent):

        """

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

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

        @param idevent: identifiant de l'évènement souhaité

        """

        events = VigiboardRequest()

        events.add_filter(Events.idevent == idevent)

        # Vérification que l'évènement existe

        if events.num_rows() != 1 :

            flash(_('Error in DB'), 'error')

            redirect('/')

        events.format_events(0, 1)

        events.format_history()

        events.generate_tmpl_context() 

        return dict(

               events = events.events,

               id_first_row = 1,

               id_last_row = 1,

               total_row = 1,

               pages = [1],

               page = 1,

               event_edit_status_options = edit_event_status_options,

               history = events.hist,

               hist_error = True

            )

    @validate(validators={'host':validators.NotEmpty(),

        'service':validators.NotEmpty()}, error_handler=process_form_errors)

    @expose('vigiboard.templates.vigiboard')

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

    def host_service(self, host, service):

        """

        Affichage de l'historique de l'ensemble des évènements correspondant au

        host et service demandé.

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

        @param host: Nom de l'hôte souhaité.

        @param service: Nom du service souhaité

        """

        events = VigiboardRequest()

        events.add_filter(Events.hostname == host,

                Events.servicename == service)

        # Vérification qu'il y a au moins 1 évènement qui correspond

        if events.num_rows() == 0 :

            redirect('/')

        events.format_events(0, events.num_rows())

        events.format_history()

        events.generate_tmpl_context() 

        return dict(

               events = events.events,

               id_first_row = 1,

               id_last_row = 1,

               total_row = 1,

               pages = [1],

               page = 1,

               event_edit_status_options = edit_event_status_options,

               history = events.hist,

               hist_error = True

            )

    @validate(validators={

        "id":validators.Regex(r'^[0-9]+(,[0-9]*)*,?$'),

        "trouble_ticket":validators.Regex(r'^[0-9]*$'),

        "status":validators.OneOf(['NoChange', 'None', 'Acknowledged',

                'AAClosed'])

        }, error_handler=process_form_errors)

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

    def update(self,**krgv):

        """

        Mise à jour d'un évènement suivant les arguments passés.

        Cela peut être un changement de ticket ou un changement de statu.

        @param krgv['id']: Le ou les identifiants des évènements à traiter

        @param krgv['tt']: Nouveau numéro du ticket associé.

        @param krgv['status']: Nouveau status de/des évènements.

        """

        # Si l'utilisateur édite plusieurs évènements à la fois,

        # il nous faut chacun des identifiants

        ids = krgv['id'].split(',')

        if len(ids) > 1 :

            ids = ids[:-1]

        events = VigiboardRequest()

        events.add_filter(Events.idevent.in_(ids))

        # Vérification que au moins un des identifiants existe et est éditable

        if events.num_rows() <= 0 :

            flash(_('No access to this event'), 'error')

            redirect('/')

        # Modification des évènements et création d'un historique

        # pour chacun d'eux

        username = request.environ.get('repoze.who.identity'

                ).get('repoze.who.userid')

        for req in events.req :

            if isinstance(req,Events):

                event = req

            else:

                event = req[0]

            if krgv['trouble_ticket'] != '' :

                event.trouble_ticket = krgv['trouble_ticket']

                history = EventHistory(type_action = "Ticket change",

                    idevent = event.idevent, value = '', text = '',

                    username = username)

                DBSession.add(history)   

            if krgv['status'] != 'NoChange' :

                event.status = krgv['status']

                history = EventHistory(

                        type_action = "Acknowlegement change state",

                        idevent = event.idevent, value = '', text = '',

                        username = username)

                DBSession.add(history)

        flash(_('Updated successfully'))

	# Redirection vers la dernière page accédée

        redirect(request.environ.get('HTTP_REFERER').split(

            request.environ.get('HTTP_HOST')+tg.config['base_url_filter.base_url'])[1])

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4: 

class VigiboardRequestPlugin(object):

    """

    Classe dont les plugins utilisé dans VigiboardRequest doivent étendre.

    """

    def __init__ (self, table = None, join = None, outerjoin = None,

            filters = None, groupby = None, orderby = None, name = '',

            style = None):

        self.table = table

        self.join = join

        self.outerjoin = outerjoin

        self.filter = filters

        self.orderby = orderby

        self.name = name

        self.groupby = groupby

        self.style = style

    def __show__ (self, event):

        """

        Permet d'éviter toutes erreurs d'affichage.

        C'est la fonction appelé par le formateur d'évènements.

        """

        show = self.show(event)

        if show != None :

            try:

                return str(show)

            except:

                return _('Error')

    def show(self, event):

        """

        Fonction qui affichera par défaut une chaîne de

        caractères vide dans la colonne attribué au plugin.

        En général, les plugins devront redéfinir cette fonction

        pour afficher ce qu'ils souhaitent.

        """

        return ''

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4: 

from vigiboard.controllers.vigiboard_ctl.vigiboard_plugin import \

        VigiboardRequestPlugin

from vigiboard.model import ServiceHautNiveau, Events

from sqlalchemy import sql, asc

from pylons.i18n import ugettext as _

class PluginSHN (VigiboardRequestPlugin):

    """

    Plugin permettant de rajouter le nombre de SHNs impactés à

    l'affichage

    """

    def __init__(self):

        super(PluginSHN,self).__init__(

            table = [ServiceHautNiveau.servicename_dep,

                sql.func.count(Events.idevent)],

            outerjoin = [(ServiceHautNiveau,

                ServiceHautNiveau.servicename_dep == Events.servicename)],

            groupby = [(Events),(ServiceHautNiveau.servicename_dep)],

            name = _(u'SHNs impacté'),

            style = {'style':'text-align:center'}

        )

    def show(self, req):

        """Fonction d'affichage"""

        if req[1] :

            return req[2]

        else :

            return None

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4: 

from vigiboard.controllers.vigiboard_ctl.vigiboard_plugin import \

	        VigiboardRequestPlugin

from vigiboard.model import EventHistory, Events

class MonPlugin(VigiboardRequestPlugin):

    """Plugin de test"""

    def __init__(self):

        super(PluginSHN,self).__init__(

            table = [EventHistory.idevent],

            join = [(EventHistory, EventHistory.idevent == Events.idevent)]

        )

    def show(self, req):

	"""Fonction d'affichage"""

	return req[1]

# -*- coding: utf-8 -*-

# vim:set expandtab tabstop=4 shiftwidth=4: 

"""Gestion de la requête, des plugins et de l'affichage du Vigiboard"""

from vigiboard.model import Events, Host, Service, \

        HostGroups, ServiceGroups, EventHistory

from tg import tmpl_context, url, config

from vigiboard.model import DBSession

from sqlalchemy import not_ , and_ , asc , desc

from tw.jquery import JQueryUIDialog

from vigiboard.widgets.edit_event import EditEventForm , SearchForm

from vigiboard.controllers.userutils import get_user_groups

from vigiboard.controllers.vigiboard_ctl.vigiboard_plugin import VigiboardRequestPlugin

from pylons.i18n import ugettext as _

class VigiboardRequest():

    """

    Classe gérant la génération de la requête finale,

    le préformatage des évènements et celui des historiques

    """

    def __init__(self):

        """

        Initialisation de toutes les variables nécessaires: Liste des groupes de

        l'utilisateur, les classes à appliquer suivant la sévérité, les

        différentes étapes de la génération de la requête et la liste des

        plugins appliqués.

        """

        self.user_groups = get_user_groups()

        self.bouton_severity = { 0: 'Minor', 1: 'Minor', 2: 'Minor',

                3: 'Minor', 4: 'Minor', 5: 'Minor', 6: 'Major', 7: 'Critical' }

        self.class_severity = { 0: 'None', 1: 'None', 2: 'None', 3: 'None',

                4: 'None', 5: 'Minor', 6: 'Major', 7: 'Critical' }

        self.severity = { 0: _('None'), 1: _('OK'), 2: _('Suppressed'),

                3: _('Initial'), 4: _('Maintenance'), 5: _('Minor'),

                6: _('Major'), 7: _('Critical') }

        self.class_ack = {'Acknowledged': 'Ack', 'None': '', 'AAClosed': 'Ack'}

        self.generaterq = False

        self.table = [Events]

        self.join = [( Host, Events.hostname == Host.name ),

                ( Service, Events.servicename == Service.name ),

                ( HostGroups , Host.name == HostGroups.hostname ),

                ( ServiceGroups , Service.name == ServiceGroups.servicename )

                ]

        self.outerjoin = []

        self.filter = [HostGroups.groupname.in_(self.user_groups),

                 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 = [desc(Events.status),

                                desc(Events.active),

                                desc(Events.severity),

                                asc(Events.hostname),

                                desc(Events.timestamp)]

        self.groupby = []

        self.plugin = []

        self.events = []

        self.idevents = []

        self.hist = []

        self.req = DBSession

    def add_plugin(self, *argv):

        """

        Ajout d'un plugin, on lui prélève ses ajouts dans la requête

        """

        for i in argv :

            if isinstance(i, VigiboardRequestPlugin):

                if i.table :

                    self.add_table(*i.table)

                if i.join :

                    self.add_join(*i.join)

                if i.outerjoin :

                    self.add_outer_join(*i.outerjoin)

                if i.filter :

                    self.add_filter(*i.filter)

                if i.groupby :    

                    self.add_group_by(*i.groupby)

                if i.orderby :

                    self.add_order_by(*i.orderby)

                self.plugin.append(i)

    def generate_request(self):

        """

        Génération de la requête avec l'ensemble des données stockées

        et la place dans la variable rq de la classe

        """

        for plug in config['vigiboard_plugins']:

            try:

                mypac = __import__(

                    'vigiboard.controllers.vigiboard_ctl.vigiboard_plugin.' +\

                            plug[0],globals(), locals(), [plug[1]],-1)

                self.add_plugin(getattr(mypac,plug[1])())

            except:

                raise

        # query et join ont besoin de referrence

        self.req = self.req.query(*self.table)

        self.req = self.req.join(*self.join)

        # le reste, non

        for i in self.outerjoin:

            self.req = self.req.outerjoin(i)

        for i in self.filter:

            self.req = self.req.filter(i)

        for i in self.groupby:

            self.req = self.req.group_by(i)

        for i in self.orderby:

            self.req = self.req.order_by(i)

    def num_rows(self):

        """

        Retourne le nombre de lignes de la requête.

        Si celle-ci n'est pas encore générée, on le fait.

        @return: Nombre de ligne

        """

        if not self.generaterq :

            self.generate_request()

            self.generaterq = True

        return self.req.count()

    def add_table(self, *argv):

        """

        Ajoute une ou plusieurs tables/élément d'une table à

        la requête.

        @param argv: Liste des tables à ajouter

        """

        #On vérifi qu'il n'y a pas de doublons dans la liste des

        #tables finale

        for i in argv :

            for j in self.table:

                if str(i) == str(j):

                    break

            self.table.append(i)

    def add_join(self, *argv):

        """

        Ajoute une ou plusieurs jointures à

        la requête.

        @param argv: Liste des jointures à ajouter

        """

        #On vérifi qu'il n'y a pas de doublons dans la liste des

        #jointures finale

        for i in argv:

            for j in self.join:

                if str(i) == str(j):

                    break

            self.join.append(i)

    def add_outer_join(self, *argv):

        """

        Ajoute une ou plusieurs jointures externes à

        la requête.

        @param argv: Liste des jointures externes à ajouter

        """

        #On vérifi qu'il n'y a pas de doublons dans la liste des

        #jointures externes finale

        for i in argv:

            for j in self.outerjoin:

                if str(i) == str(j):

                    break

            self.outerjoin.append(i)    

    def add_filter(self, *argv):

        """

        Ajoute un ou plusieurs filtres à la requête.

        @param argv: Liste des filtres à ajouter

        """

        #On vérifi qu'il n'y a pas de doublons dans la liste des

        #filtres finale

        for i in argv:

            for j in self.filter:

                if str(i) == str(j):

                    break

            self.filter.append(i)

    def add_group_by(self, *argv):

        """

        Ajoute un ou plusieurs groupements à la requête.

        @param argv: Liste des groupements à ajouter

        """

        #On vérifi qu'il n'y a pas de doublons dans la liste des

        #groupements finale

        for i in argv:

            for j in self.groupby:

                if str(i) == str(j):

                    break

            self.groupby.append(i)

    def add_order_by(self, *argv):

        """

        Ajoute un ou plusieurs orders à la requête.

        @param argv: Liste des ordres à ajouter

        """

        #On vérifi qu'il n'y a pas de doublons dans la liste des

        #ordres finale

        for i in argv:

            for j in self.orderby:

                if str(i) == str(j):

                    break

            self.orderby.append(i)

    def format_events_img_statu (self, event):

        """

        Suivant l'état de l'évènement, retourne la classe à appliquer

        à l'image indiquant si l'évènement est pris en compte ou non.

        @param event: l'évènement à analyser

        @return: Dictionnaire représentant la classe à appliquer

        """

        if event.active and event.status == 'AAClosed':

            return { 'src': url('/images/crossed.png') }

        elif event.status == 'Acknowledged' :

            return { 'src': url('/images/checked.png') }

        else:

            return None

    def format_events(self, first_row, last_row):

        """

        Formate la réponse de la requête et y applique les plugins

        pour un affichage simple du résultat par Genshi.

        On génère une liste de liste, chaqu'une étant la description de

        l'affichage pour un évènement donné.

        @param first_row: Indice de début de la liste des évènements

        @param last_row: Indice de fin de la liste des évènements

        """

        # Si la requête n'est pas générée, on le fait

        if not self.generaterq :

            self.generate_request()

            self.generaterq = True

        # Liste des éléments pour la tête du tableau

        lst_title = ['', _('Date<br />[Duration]'), '#', _('Host'),

                _('Service Type<br />Service Name'), _('Output')]

        lst_title.extend([plug.name for plug in self.plugin])

        lst_title.extend(['[T T]', ''])

        events = [lst_title]

        i = 0

        class_tr = ['odd', 'even']

        ids = []

        for req in self.req[first_row : last_row]:

            # Si il y a plus d'un élément dans la liste des tables,

            # rq devient une liste plutôt que d'être directement la

            # table souhaité

            if isinstance(req, Events) :

                event = req

            else :

                event = req[0]

            ids.append(event.idevent)

            # La liste pour l'évènement actuel comporte dans l'ordre :

            #   L'évènment en lui même

            #   La classe à appliquer sur la ligne (permet d'alterner les

            #       couleurs suivant les lignes)

            #   La classe pour la case comportant la flèche de détails

            #   La classe pour la date, l'occurrence et l'édition

            #   L'image a affiche pour la flèche de détails

            #   Une liste (une case par plugin) de ce que le plugin souhaite

            #       afficher en fonction de l'évènement

            if event.active :

                events.append([

                    event,

                    {'class': class_tr[i%2]},

                    {'class' : self.bouton_severity[event.severity] + \

                            self.class_ack[event.status]},

                    {'class' : self.bouton_severity[event.severity] + \

                            self.class_ack[event.status] },

                    {'src' : '/images/%s2.png' % \

                            self.bouton_severity[event.severity].upper()},

                    self.format_events_img_statu(event),

                    [[j.__show__(req), j.style] for j in self.plugin]

                    ])

            else :

                events.append([

                    event,

                    {'class': class_tr[i%2]},

                    {'class' : self.bouton_severity[event.severity] + \

                            self.class_ack[event.status] },

                    {'class' : 'Cleared' + self.class_ack[event.status] },

                    {'src' : '/images/%s2.png' % \

                            self.bouton_severity[event.severity].upper()},

                    self.format_events_img_statu(event),

                    [[j.__show__(req), j.style] for j in self.plugin]

                    ])

            i = i + 1

        # On sauvegarde la liste précédemment créée puis rempli

        # le TmplContext

        self.events = events

        self.idevents = ids

    def format_history (self):

        """

        Formate les historiques correspondant aux évènements sélectionnés

        pour un affichage simple du résultat par Genshi.

        On génère une liste de liste, chaqu'une étant la description de l'affichage pour un

        historique donné.

        """

        history = DBSession.query(EventHistory

                ).filter(EventHistory.idevent.in_(self.idevents)

                ).order_by(desc(EventHistory.timestamp)

                ).order_by(desc(EventHistory.idhistory))