"vigiboard",

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

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

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

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

        Column(u'snmpversion',

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

            primary_key=False),

        mysql_engine='InnoDB',

        mysql_charset='utf8'

    )

# Classe a mapper

class Host(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, name, checkhostcmd = '', community = '', fqhn = '',

            hosttpl = '', mainip = '', port = 0, snmpoidsperdu = 0,

            snmpversion = ''):

        self.name = name

        self.checkhostcmd = checkhostcmd

        self.community = community

        self.fqhn = fqhn

        self.hosttpl = hosttpl

        self.mainip = mainip

        self.port = port

        self.snmpoidsperdu = snmpoidsperdu

        self.snmpversion = snmpversion

mapper(Host, host)

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

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

"""Modèle pour la table HostGroups"""

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

hostgroups = Table(bdd_basename + 'hostgroups',

    metadata,

    Column(u'hostname',

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

        ForeignKey(bdd_basename + u'host.name'),

        primary_key=True, nullable=False),

    Column(u'groupname',

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

        ForeignKey(bdd_basename + u'groups.name'),

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

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class HostGroups(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, hostname, groupname):

        self.hostname = hostname

        self.groupname = groupname

mapper(HostGroups, hostgroups)

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

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

"""Modèle pour la table PerfDataSource"""

from __future__ import absolute_import

from sqlalchemy.orm import mapper

from sqlalchemy import Table, ForeignKey, Column

from sqlalchemy.types import String, Float

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

perfdatasource = Table(

    bdd_basename + 'perfdatasource',

    metadata,

    Column(u'hostname',

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

        ForeignKey(bdd_basename + u'host.name'),

        primary_key=True, nullable=False),

    Column(u'servicename',

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

        ForeignKey(

            bdd_basename + u'service.name'

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

    Column(u'graphname',

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

        ForeignKey(bdd_basename + u'graph.name'),

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

    Column(u'type',

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

        primary_key=False, nullable=False),

    Column(u'label',

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

        primary_key=False),

    Column(u'factor',

        Float(precision=None, asdecimal=False),

        primary_key=False, nullable=False),

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class PerfDataSource(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, hostname, servicename, graphname, typeperf = '',

            label = '', factor = 0.0):

        self.hostname = hostname

        self.servicename = servicename

        self.graphname = graphname

        self.type = typeperf

        self.label = label

        self.factor = factor

mapper(PerfDataSource, perfdatasource)

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

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

"""Modèle pour la table Service"""

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

service =  Table(bdd_basename + 'service',

        metadata,

        Column(u'name',

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

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

        Column(u'type',

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

            primary_key=False, nullable=False),

        Column(u'command',

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

            primary_key=False, nullable=False),

        mysql_engine='InnoDB',

        mysql_charset='utf8'

    )

# Classe a mapper

class Service(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, name, servicetype = 0, command = ''):

        self.name = name

        self.type = servicetype

        self.command = command

mapper(Service, service)

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

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

"""Modèle pour la table ServiceGroups"""

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

servicegroups =  Table(

    bdd_basename + 'servicegroups',

    metadata,

    Column(u'servicename',

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

        ForeignKey(

            bdd_basename + u'service.name'

        ), primary_key=True, nullable=False),

    Column(u'groupname',

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

        ForeignKey(

            bdd_basename + u'groups.name'

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

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class ServiceGroups(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, servicename, groupname):

        self.servicename = servicename

        self.groupname = groupname

mapper(ServiceGroups, servicegroups)

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

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

"""Modèle pour la table ServiceHautNiveau"""

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

servicehautniveau = Table(

    bdd_basename + 'servicehautniveau',

    metadata,

    Column(u'servicename',

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

        ForeignKey(

            bdd_basename + u'service.name'

        ), primary_key=True, nullable=False),

    Column(u'servicename_dep',

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

        ForeignKey(

            bdd_basename + u'service.name'

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

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class ServiceHautNiveau(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, servicename, servicename_dep):

        self.servicename = servicename

        self.servicename_dep = servicename_dep

mapper(ServiceHautNiveau, servicehautniveau)

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

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

"""Modèle pour la table ServiceTopo"""

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

servicetopo =  Table(bdd_basename + 'servicetopo',

    metadata,

    Column(u'servicename',

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

        ForeignKey(bdd_basename + \

                u'service.name'),

        primary_key=True, nullable=False),

    Column(u'function',

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

        primary_key=False, nullable=False),

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class ServiceTopo(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, servicename, function=''):

        self.servicename = servicename

        self.function = function

mapper(ServiceTopo, servicetopo)

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

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

"""Modèle pour la table State"""

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

from datetime import datetime

from ..vigilo_bdd_config import bdd_basename, metadata

# Generation par SQLAutoCode

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

    Column(u'idstat', 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'ip',

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

        primary_key=False),

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

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

        primary_key=False, nullable=False,

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

    Column(u'type', MSEnum('SOFT','HARD'),

        primary_key=False, nullable=False,

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

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

        autoincrement=False),

    Column(u'message',

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

        primary_key=False),

    mysql_engine='InnoDB',

    mysql_charset='utf8'

)

# Classe a mapper

class State(object):

    """

    Classe liée avec la table associée

    """

    def __init__(self, hostname, servicename, ip, timestamp = datetime.now(), 

            statename = 'OK', type = 'SOFT', attempt = 1, message = ''):

        self.hostname = hostname

        self.servicename = servicename

        self.ip = ip

        self.timestamp = timestamp

        self.statename = statename

        self.type = type

        self.attempt = attempt

        self.message = message

mapper(State, state)

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

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

"""Modèle pour la table Version"""

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

version = Table(bdd_basename + 'version',

        metadata,

        Column(u'name',

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

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

        Column(u'version',

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

            primary_key=False, nullable=False),

        mysql_engine='InnoDB',

        mysql_charset='utf8'

    )

# Classe a mapper

class Version(object):

    """

    Classe liée avec la table associée

    """

    pass

mapper(Version, version)