Vigiboard Module

# -*- 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.vigiboard_conf import vigiboard_config

from paste.cascade import Cascade

from paste.urlparser import StaticURLParser

__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

    try:

        # chargement de l'application

        myapp = __import__(app_conf['appname'] ,globals(), locals(), [],-1)

        base_config.package = myapp

        # chargement de la conf de l'application

        myconf = __import__(

            app_conf['appname'] + '.config.' + app_conf['appname'] ,globals(), locals(), [app_conf['appname'] + '_config'],-1)

        myconf = getattr(myconf,app_conf['appname'] + '_config')

        for conf in myconf:

            app_conf[conf] = myconf[conf]

    except:

        print "vigilo-core runing without application"

    for i in vigiboard_config:

        app_conf[i] = vigiboard_config[i]

    # on cré l'application de base

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

    # on rajoute le path public de l'application

    import vigiboard

    app = Cascade([

        StaticURLParser(global_conf['here'] + '/' + app_conf['appname']  + '/public'),

        StaticURLParser(vigiboard.__file__.rsplit('/',1)[0] + '/public'),app]

        )

    return app

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

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

"""Configuration de Vigiboard."""

vigiboard_config = {

        'vigiboard_bdd.basename' : ''

}

# -*- 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 -*-

"""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

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

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

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

class Vigiboard_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__()

#        a = config['app_conf']['appname']

#        p = __import__(a + '.config.' + a,globals(), locals(), [a + '_config'],-1)

#        print getattr(p,a + '_config')

#

#        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 -*-

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

"""The application's Globals object"""

__all__ = ['Globals']

class Globals(object):

    """Container for objects available throughout the life of the application.

    One instance of Globals is created during application initialization and

    is available during requests via the 'app_globals' variable.

    """

    def __init__(self):

        """Do nothing, by default."""

        pass

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

"""The base Controller API."""

from tg import TGController, tmpl_context

from tg.render import render

from tg import request

from pylons.i18n import _, ungettext, N_

from tw.api import WidgetBunch

import vigiboard.model as model

__all__ = ['Controller', 'BaseController']

class BaseController(TGController):

    """

    Base class for the controllers in the application.

    Your web application should have one of these. The root of

    your application is used to compute URLs used by your app.

    """

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # TGController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

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

        tmpl_context.identity = request.identity

        return TGController.__call__(self, environ, start_response)

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

"""WebHelpers used in vigiboard."""

from webhelpers import date, feedgenerator, html, number, misc, text

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

"""The application's model objects"""

from zope.sqlalchemy import ZopeTransactionExtension

from sqlalchemy.orm import scoped_session, sessionmaker

#from sqlalchemy import MetaData

from sqlalchemy.ext.declarative import declarative_base

# Global session manager: DBSession() returns the Thread-local

# session object appropriate for the current web request.

maker = sessionmaker(autoflush=True, autocommit=False,

                     extension=ZopeTransactionExtension())

DBSession = scoped_session(maker)

# Base class for all of our model classes: By default, the data model is

# defined with SQLAlchemy's declarative extension, but if you need more

# control, you can switch to the traditional method.

DeclarativeBase = declarative_base()

# There are two convenient ways for you to spare some typing.

# You can have a query property on all your model classes by doing this:

# DeclarativeBase.query = DBSession.query_property()

# Or you can use a session-aware mapper as it was used in TurboGears 1:

# DeclarativeBase = declarative_base(mapper=DBSession.mapper)

# Global metadata.

# The default metadata is the one from the declarative base.

metadata = DeclarativeBase.metadata

# If you have multiple databases with overlapping table names, you'll need a

# metadata for each database. Feel free to rename 'metadata2'.

#metadata2 = MetaData()

#####

# Generally you will not want to define your table's mappers, and data objects

# here in __init__ but will want to create modules them in the model directory

# and import them at the bottom of this file.

#

######

def init_model(engine):

    """Call me before using any of the tables or classes in the model."""

    DBSession.configure(bind=engine)

    # If you are using reflection to introspect your database and create

    # table objects for you, your tables must be defined and mapped inside

    # the init_model function, so that the engine is available if you

    # use the model outside tg2, you need to make sure this is called before

    # you use the model.

    #

    # See the following example:

    #global t_reflected

    #t_reflected = Table("Reflected", metadata,

    #    autoload=True, autoload_with=engine)

    #mapper(Reflected, t_reflected)

# Import your model modules here.

from vigiboard.model.auth import User, Group, Permission

from vigiboard.model.vigilo_bdd import Events, EventHistory, Graph, \

    GraphGroups, GraphToGroups, Groups, GroupPermissions, HostGroups, Host, \

    PerfDataSource, ServiceGroups, ServiceHautNiveau, Service, ServiceTopo

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

"""

Auth* related model.

This is where the models used by :mod:`repoze.who` and :mod:`repoze.what` are

defined.

It's perfectly fine to re-use this definition in the vigiboard application,

though.

"""

import os

from datetime import datetime

import sys

try:

    from hashlib import sha1

except ImportError:

    sys.exit('ImportError: No module named hashlib\n'

             'If you are on python2.4 this library is not part of python. '

             'Please install it. Example: easy_install hashlib')

from sqlalchemy import Table, ForeignKey, Column

from sqlalchemy.types import Unicode, Integer, DateTime

from sqlalchemy.orm import relation, synonym

from vigiboard.model import DeclarativeBase, metadata, DBSession

__all__ = ['User', 'Group', 'Permission']

#{ Association tables

# This is the association table for the many-to-many relationship between

# groups and permissions. This is required by repoze.what.

group_permission_table = Table('tg_group_permission', metadata,

    Column('group_id', Integer, ForeignKey('tg_group.group_id',

        onupdate="CASCADE", ondelete="CASCADE")),

    Column('permission_id', Integer, ForeignKey('tg_permission.permission_id',

        onupdate="CASCADE", ondelete="CASCADE")),

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# This is the association table for the many-to-many relationship between

# groups and members - this is, the memberships. It's required by repoze.what.

user_group_table = Table('tg_user_group', metadata,

    Column('user_id', Integer, ForeignKey('tg_user.user_id',

        onupdate="CASCADE", ondelete="CASCADE")),

    Column('group_id', Integer, ForeignKey('tg_group.group_id',

        onupdate="CASCADE", ondelete="CASCADE")),

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

#{ The auth* model itself

class Group(DeclarativeBase):

    """

    Group definition for :mod:`repoze.what`.

    Only the ``group_name`` column is required by :mod:`repoze.what`.

    """

    __tablename__ = 'tg_group'

    __table_args__ = {'mysql_engine':'InnoDB', 'mysql_charset':'utf8'}

    #{ Columns

    group_id = Column(Integer, autoincrement=True, primary_key=True)

    group_name = Column(Unicode(16), unique=True, nullable=False)

    display_name = Column(Unicode(255))

    created = Column(DateTime, default=datetime.now)

    #{ Relations

    users = relation('User', secondary=user_group_table, backref='groups')

    #{ Special methods

    def __repr__(self):

        return '<Group: name=%s>' % self.group_name

    def __unicode__(self):

        return self.group_name

    #}

# The 'info' argument we're passing to the email_address and password columns

# contain metadata that Rum (http://python-rum.org/) can use generate an

# admin interface for your models.

class User(DeclarativeBase):

    """

    User definition.

    This is the user definition used by :mod:`repoze.who`, which requires at

    least the ``user_name`` column.

    """

    __tablename__ = 'tg_user'

    __table_args__ = {'mysql_engine':'InnoDB', 'mysql_charset':'utf8'}

    #{ Columns

    user_id = Column(Integer, autoincrement=True, primary_key=True)

    user_name = Column(Unicode(16), unique=True, nullable=False)

    email_address = Column(Unicode(255), unique=True, nullable=False,

                           info={'rum': {'field':'Email'}})

    display_name = Column(Unicode(255))

    _password = Column('password', Unicode(80),

                       info={'rum': {'field':'Password'}})

    created = Column(DateTime, default=datetime.now)

    #{ Special methods

    def __repr__(self):

        return '<User: email="%s", display name="%s">' % (

                self.email_address, self.display_name)

    def __unicode__(self):

        return self.display_name or self.user_name

    #{ Getters and setters

    @property

    def permissions(self):

        """Return a set of strings for the permissions granted."""

        perms = set()

        for g in self.groups:

            perms = perms | set(g.permissions)

        return perms

    @classmethod

    def by_email_address(cls, email):

        """Return the user object whose email address is ``email``."""

        return DBSession.query(cls).filter(cls.email_address==email).first()

    @classmethod

    def by_user_name(cls, username):

        """Return the user object whose user name is ``username``."""

        return DBSession.query(cls).filter(cls.user_name==username).first()

    def _set_password(self, password):

        """Hash ``password`` on the fly and store its hashed version."""

        hashed_password = password

        if isinstance(password, unicode):

            password_8bit = password.encode('UTF-8')

        else:

            password_8bit = password

        salt = sha1()

        salt.update(os.urandom(60))

        hash = sha1()

        hash.update(password_8bit + salt.hexdigest())

        hashed_password = salt.hexdigest() + hash.hexdigest()

        # Make sure the hashed password is an UTF-8 object at the end of the

        # process because SQLAlchemy _wants_ a unicode object for Unicode

        # columns

        if not isinstance(hashed_password, unicode):

            hashed_password = hashed_password.decode('UTF-8')

        self._password = hashed_password

    def _get_password(self):

        """Return the hashed version of the password."""

        return self._password

    password = synonym('_password', descriptor=property(_get_password,

                                                        _set_password))

    #}

    def validate_password(self, password):

        """

        Check the password against existing credentials.

        :param password: the password that was provided by the user to

            try and authenticate. This is the clear text version that we will

            need to match against the hashed one in the database.

        :type password: unicode object.

        :return: Whether the password is valid.

        :rtype: bool

        """

        hashed_pass = sha1()

        hashed_pass.update(password + self.password[:40])

        return self.password[40:] == hashed_pass.hexdigest()

class Permission(DeclarativeBase):

    """

    Permission definition for :mod:`repoze.what`.

    Only the ``permission_name`` column is required by :mod:`repoze.what`.

    """

    __tablename__ = 'tg_permission'

    __table_args__ = {'mysql_engine':'InnoDB', 'mysql_charset':'utf8'}

    #{ Columns

    permission_id = Column(Integer, autoincrement=True, primary_key=True)

    permission_name = Column(Unicode(16), unique=True, nullable=False)

    description = Column(Unicode(255))

    #{ Relations

    groups = relation(Group, secondary=group_permission_table,

                      backref='permissions')

    #{ Special methods

    def __repr__(self):

        return '<Permission: name=%s>' % self.permission_name

    def __unicode__(self):

        return self.permission_name

    #}

#}

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

"""Sample model module."""

from sqlalchemy import *

from sqlalchemy.orm import mapper, relation

from sqlalchemy import Table, ForeignKey, Column

from sqlalchemy.types import Integer, Unicode

#from sqlalchemy.orm import relation, backref

from vigiboard.model import DeclarativeBase, metadata, DBSession

class SampleModel(DeclarativeBase):

    __tablename__ = 'sample_model'

    #{ Columns

    id = Column(Integer, primary_key=True)

    data = Column(Unicode(255), nullable=False)

    #}

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

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

"""BdD Vigiboard"""

from .eventhistory import EventHistory

from .events import Events

from .graphgroups import GraphGroups

from .graph import Graph

from .groups import Groups

from .grouppermissions import GroupPermissions

from .hostgroups import HostGroups

from .host import Host

from .perfdatasource import PerfDataSource

from .servicegroups import ServiceGroups

from .servicehautniveau import ServiceHautNiveau

from .service import Service

from .servicetopo import ServiceTopo

from .graphtogroups import GraphToGroups

from .version import Version

from .state import State

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

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

"""Modèle pour la table EventHistory"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import ForeignKey, Table, Column

from sqlalchemy.types import Integer, String, Text, DateTime

from sqlalchemy.databases.mysql import MSEnum

from datetime import datetime

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

event_history =  Table(

    bdd_basename + 'event_history', metadata,

    Column(u'idhistory', Integer(), primary_key=True, nullable=False, 

        autoincrement=True),

    Column(u'type_action',

        MSEnum('Nagios update state', 'Acknowlegement change state',

            'New occurence', 'User comment', 'Ticket change', 'Oncall',

            'Forced state'),

        primary_key=False, nullable=False),

    Column(u'idevent', Integer(),

        ForeignKey(

            bdd_basename +'events.idevent'

        ), index=True, primary_key=False, nullable=False),

    Column(u'value',

        String(length=255, convert_unicode=True, assert_unicode=None),

        primary_key=False),

    Column(u'text',

        Text(length=None, convert_unicode=True, assert_unicode=None),

        primary_key=False),

    Column(u'timestamp', DateTime(timezone=False), default=datetime.now(),

        primary_key=False),

    Column(u'username',

        String(length=255, convert_unicode=True, assert_unicode=None),

        primary_key=False),

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class EventHistory(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, type_action, idevent, value='', text='', username=''):

        """

        Fonction d'initialisation, permet de faire un INSERT en une fonction

        @param type_action: Le type d'action effectué, peut être 'Nagios update state',

                            'Acknowlegement change state', 'New occurence', 'User comment', 'Ticket change',

                            'Oncall' ou 'Forced state'

        @param idevent: Identifiant de l'évènement

        @param value: Nouvelle sévérité

        @param text: Commentaire sur l'action effectuée

        @param username: Nom d'utilisateur de la personne effectuant l'action

        """

        self.type_action = type_action

        self.idevent = idevent 

        self.value = value

        self.text = text

        self.username = username

mapper(EventHistory, event_history)

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

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

"""Modèle pour la table Events"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import Table, Column, DefaultClause, ForeignKey

from sqlalchemy.types import Integer, String, Text, DateTime

from sqlalchemy.databases.mysql import MSEnum, MSBoolean

from datetime import datetime

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

events = Table(bdd_basename + 'events', metadata,

    Column(u'idevent', Integer(), primary_key=True, nullable=False,

        autoincrement=True),

    Column(u'hostname',

        String(length=100, convert_unicode=True, assert_unicode=None),

        ForeignKey(bdd_basename +'host.name'),

        index=True, primary_key=False, nullable=False),

    Column(u'servicename',

        String(length=100, convert_unicode=True, assert_unicode=None),

        ForeignKey(bdd_basename + 'service.name'),

        index=True, primary_key=False),

    Column(u'severity', Integer(), primary_key=False, nullable=False),

    Column(u'status', MSEnum('None','Acknowledged','AAClosed'), 

        primary_key=False, nullable=False, 

        server_default=DefaultClause('None', for_update=False)),

    Column(u'active', MSBoolean(), primary_key=False, default='True'),

    Column(u'timestamp', DateTime(timezone=False), primary_key=False),

    Column(u'output',

        Text(length=None, convert_unicode=True, assert_unicode=None),

        primary_key=False, nullable=False),

    Column(u'timestamp_active', DateTime(timezone=False), primary_key=False),

    Column(u'trouble_ticket',

        String(length=20, convert_unicode=True, assert_unicode=None),

        primary_key=False),

    Column(u'occurence', Integer(), primary_key=False),

    Column(u'impact', Integer(), primary_key=False),

    Column(u'rawstate', MSEnum('WARNING','OK','CRITICAL','UNKNOWN')),

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class Events(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, hostname, servicename, server_source = '', severity = 0,

            status = 'None', active = True, timestamp = datetime.now(), 

            output = '', event_timestamp = datetime.now(),

            last_check = datetime.now(), recover_output = '',

            timestamp_active = datetime.now(),

            timestamp_cleared=None, trouble_ticket = None,

            occurence = 1):

        self.hostname = hostname

        self.servicename = servicename

        self.server_source = server_source

        self.severity = severity

        self.status = status

        self.active = active

        self.timestamp = timestamp

        self.output = output

        self.event_timestamp = event_timestamp

        self.last_check = last_check

        self.recover_output = recover_output

        self.timestamp_active = timestamp_active

        self.timestamp_cleared = timestamp_cleared

        self.trouble_ticket = trouble_ticket

        self.occurence = occurence

    def get_date(self, element):

        """

        Permet de convertir une variable de temps en la chaîne de caractère : 

        jour mois heure:minutes:secondes

        @param element: nom de l'élément à convertir de la classe elle même

        """

        element = self.__dict__[element]

        date = datetime.now() - element

        if date.days < 7 :

            return element.strftime('%a %H:%M:%S')

        else :    

            return element.strftime('%d %b %H:%M:%S')

    def get_since_date(self, element):

        """

        Permet d'obtenir le temps écoulé entre maintenant (datetime.now())

        et le temps contenu dans la variable de temps indiquée

        @param element: nom de l'élément de la classe elle même à utiliser

                        pour le calcul

        """

        date = datetime.now() - self.__dict__[element]

        minutes, seconds = divmod(date.seconds, 60)

        hours, minutes = divmod(minutes, 60)

        return "%dd %dh %d'" % (date.days , hours , minutes)

mapper(Events, events)

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

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

"""Modèle pour la table Graph"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import Table, Column

from sqlalchemy.types import String

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

graph =  Table(bdd_basename + 'graph',

        metadata,

        Column(u'name',

            String(length=100, convert_unicode=True, assert_unicode=None),

            primary_key=True, nullable=False),

        Column(u'template',

            String(length=2500, convert_unicode=True, assert_unicode=None),

            primary_key=False, nullable=False),

        Column(u'vlabel',

            String(length=2500, convert_unicode=True, assert_unicode=None),

            primary_key=False, nullable=False),

        mysql_engine='InnoDB',

        mysql_charset='utf8'

    )

# Classe a mapper

class Graph(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, name, template = '', vlabel = ''):

        self.name = name

        self.template = template

        self.vlabel = vlabel

mapper(Graph, graph)

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

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

"""Modèle pour la table GraphGroups"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import Table, Column

from sqlalchemy.types import Integer, String

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

graphgroups = Table(bdd_basename + 'graphgroups',

        metadata,

        Column(u'name',

            String(length=100, convert_unicode=True, assert_unicode=None),

            primary_key=True, nullable=False),

        Column(u'parent', Integer(), primary_key=False, nullable=True),

        mysql_engine='InnoDB',

        mysql_charset='utf8'

    )

# Classe a mapper

class GraphGroups(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, name, parent=None):

        self.name = name

        self.parent = parent

mapper(GraphGroups, graphgroups)

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

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

"""Modèle pour la table GraphToGroups"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import Table, ForeignKey, Column

from sqlalchemy.types import String

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

graphtogroups =  Table(

    bdd_basename + 'graphtogroups',

    metadata,

    Column(u'graphname',

        String(length=100, convert_unicode=False, assert_unicode=None),

        ForeignKey(bdd_basename + 'graph.name'),

        primary_key=True, nullable=False),

    Column(u'groupname',

        String(length=100, convert_unicode=False, assert_unicode=None),

        ForeignKey(bdd_basename + \

                'graphgroups.name'),

        primary_key=True, nullable=False),

        mysql_engine='InnoDB',

        mysql_charset='utf8'

    )

# Classe a mapper

class GraphToGroups(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, graphname, groupname):

        self.graphname = graphname

        self.groupname = groupname

mapper(GraphToGroups, graphtogroups)

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

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

"""Modèle pour la table GroupPermissions"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import Table, ForeignKey, Column

from sqlalchemy.types import Integer, String

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

grouppermissions = Table(

    bdd_basename + 'grouppermissions',

    metadata,

    Column(u'groupname',

        String(length=100, convert_unicode=True, assert_unicode=None),

        ForeignKey(bdd_basename +'groups.name'),

        primary_key=True, nullable=False),

    Column(u'idpermission',

        Integer(), autoincrement=False, primary_key=True, nullable=False),

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class GroupPermissions(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, groupname, idpermission = 0):

        self.groupname = groupname

        self.idpermission = idpermission

mapper(GroupPermissions, grouppermissions)

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

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

"""Modèle pour la table Groups"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import Table, Column

from sqlalchemy.types import String

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

groups =  Table(bdd_basename + 'groups',

        metadata,

        Column(u'name',

            String(length=100, convert_unicode=True, assert_unicode=None),

            primary_key=True, nullable=False),

        Column(u'parent',

            String(length=100, convert_unicode=True, assert_unicode=None),

            index=True, primary_key=False),

        mysql_engine='InnoDB',

        mysql_charset='utf8'

    )

# Classe a mapper

class Groups(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, name, parent=None):

        self.name = name

        self.parent = parent

mapper(Groups, groups)

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

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

"""Modèle pour la table Host"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import Table, Column

from sqlalchemy.types import Integer, String

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

host = Table(bdd_basename + 'host',

        metadata,

        Column(u'name',

            String(length=255, convert_unicode=True, assert_unicode=None),

            index=True,primary_key=True, nullable=False),

        Column(u'checkhostcmd',

            String(length=255, convert_unicode=True, assert_unicode=None),

            primary_key=False, nullable=False),

        Column(u'community',

            String(length=255, convert_unicode=True, assert_unicode=None),

            primary_key=False, nullable=False),

        Column(u'fqhn',

            String(length=255, convert_unicode=True, assert_unicode=None),

            primary_key=False, nullable=False),

        Column(u'hosttpl',

            String(length=255, convert_unicode=True, assert_unicode=None),

            primary_key=False, nullable=False),

        Column(u'mainip',

            String(length=255, convert_unicode=True, assert_unicode=None),

            primary_key=False, nullable=False),

        Column(u'port', Integer(), primary_key=False, nullable=False),