jm2l/jm2l/models.py

# -*- coding: utf8 -*-
import datetime
import sqlalchemy as sa
import hashlib
from pyramid.security import unauthenticated_userid
from sqlalchemy.orm import relationship, backref
from sqlalchemy import func
from sqlalchemy import or_
from sqlalchemy import (
    Column,
    Integer,
    Unicode,
    UnicodeText,
    DateTime,
    Enum,
    Boolean,
    ForeignKey
)

from slugify import slugify
# from webhelpers.text import urlify
from paginate import Page  # PageURL_WebOb

from webhelpers2.date import time_ago_in_words

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy.orm import (
    scoped_session,
    sessionmaker
)

# from zope.sqlalchemy import ZopeTransactionExtension
from zope.sqlalchemy import register
from jm2l.const import CurrentYear

from passlib.hash import argon2


def urlify(in_string, in_string_length):
    return ''.join('%20' if c == ' ' else c for c in in_string[:in_string_length])


DBSession = scoped_session(sessionmaker(autoflush=False))
register(DBSession)

# DBSession = scoped_session(sessionmaker(extension=ZopeTransactionExtension()))
Base = declarative_base()


class TasksArea(Base):
    __tablename__ = 'staff_tasks_area'
    uid = Column(Integer, primary_key=True)
    year_uid = Column(Integer, ForeignKey('jm2l_year.year_uid'), default=CurrentYear)
    name = Column(Unicode(80))
    description = Column(UnicodeText)

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.uid == uid).first()


class Tasks(Base):
    __tablename__ = 'staff_tasks'
    uid = Column(Integer, primary_key=True)
    area_uid = Column(Integer, ForeignKey('staff_tasks_area.uid'))
    year_uid = Column(Integer, ForeignKey('jm2l_year.year_uid'), default=CurrentYear)
    due_date = Column(DateTime, default=None)
    closed_by = Column(Integer, ForeignKey('users.uid'))
    closed_date = Column(DateTime, default=None)
    closed = Column(Integer, default=0)
    name = Column(Unicode(80))
    description = Column(UnicodeText)
    area = relationship(TasksArea, backref=backref("tasks"))

    assignee = relationship('User', backref=backref("task_assoc"))

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.uid == uid).first()


class User_Event(Base):
    """ Créer le lien entre la personne et l' évenement en fonction de l'année"""
    __tablename__ = 'user_event_link'
    uid = Column(Integer, primary_key=True)
    event_uid = Column(Integer, ForeignKey('events.uid'))
    # , primary_key=True)
    #
    user_uid = Column(Integer, ForeignKey('users.uid'))
    # , primary_key=True)
    #
    year_uid = Column(Integer, ForeignKey('jm2l_year.year_uid'), default=CurrentYear)
    role = Column(Unicode(80))
    # Define some relation
    # user     = relationship('User', backref=backref("events_assoc") )
    # event    = relationship('events', backref=backref("users_assoc") )


class JM2L_Year(Base):
    __tablename__ = 'jm2l_year'
    year_uid = Column(Integer, primary_key=True)
    description = Column(UnicodeText)
    doss_presse = Column(UnicodeText)
    state = Column(Enum('Archived', 'Cancelled', 'Ongoing'))
    start_time = Column(DateTime, default=datetime.datetime.now)
    end_time = Column(DateTime, default=datetime.datetime.now)
    created = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)

    @classmethod
    def get_latest_jm2l_startdate(cls, fakeparam=None):
        """ This property will return latest JM2L planned event startdate from database """
        last_record = DBSession.query(JM2L_Year) \
            .filter(JM2L_Year.start_time ==
                    DBSession.query(func.max(JM2L_Year.start_time))
                    ).one()
        return last_record.start_time.strftime("%A %d %B %Y") # .decode('utf-8')

    @property
    def AvailableTimeSlots(self, TimeStep=30):
        available = self.end_time - self.start_time
        nb_minutes = available.total_seconds() / 60
        nb_steps = nb_minutes / TimeStep
        # Create the range of date each 30min
        date_list = [self.start_time + datetime.timedelta(minutes=TimeStep * x) for x in range(0, int(nb_steps))]
        # Remove out of range datetime
        # Remove hours > 19h
        date_list = filter(lambda x: x.hour < 19, date_list)
        # Remove hours < 10h
        date_list = filter(lambda x: x.hour >= 10, date_list)
        # Remove 12h < hours < 13h
        date_list = filter(lambda x: x.hour < 12 or x.hour >= 13, date_list)
        return list(date_list)

    @property
    def DocLinks(self):
        from .upload import MediaPath
        return sorted(MediaPath().get_all('presse', self.year_uid))


class User(Base):
    __tablename__ = 'users'
    uid = Column(Integer, primary_key=True)
    user_id = Column(Integer)
    nom = Column(Unicode(80))
    prenom = Column(Unicode(80))
    pseudo = Column(Unicode(80))
    slug = Column(Unicode(164))
    mail = Column(Unicode(100))
    password = Column(Unicode(100), nullable=False)
    fonction = Column(Unicode(80))
    website = Column(Unicode(100))
    phone = Column(Unicode(10))
    created = Column(DateTime, default=datetime.datetime.now)
    last_logged = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)
    active = Column(Integer, default=1)
    bio = Column(UnicodeText)
    gpg_key = Column(UnicodeText)
    soc_link = Column(UnicodeText)
    Staff = Column(Integer, default=0)
    vote_logo = Column(Integer, default=0)

    wifi_user = Column(Unicode(80), nullable=True)
    wifi_pass = Column(Unicode(80), nullable=True)

    # relations    
    tiers = relationship('Tiers', secondary='user_tiers_link')
    events = relationship('Event', secondary='user_event_link')
    tiersship = relationship('User_Tiers', backref="matching_users")

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.uid == uid).first()

    @classmethod
    def by_mail(cls, mail):
        return DBSession.query(cls).filter(cls.mail == mail).first()

    @classmethod
    def by_slug(cls, slug):
        return DBSession.query(cls).filter(cls.slug == slug).first()

    @classmethod
    def by_user_id(cls, user_id):
        return DBSession.query(cls).filter(cls.user_id == user_id).first()

    @classmethod
    def by_name(cls, name):
        return DBSession.query(cls).filter(cls.nom == name).first()

    @classmethod
    def by_hash(cls, tsthash):
        for u in DBSession.query(cls):
            if u.my_hash == tsthash:
                return u
        return None

    @property
    def is_Intervenant(self):
        """ This property will return if User do an event on specified year """
        return DBSession.query(Event).join(User_Event) \
            .filter(User_Event.user_uid == self.uid) \
            .filter(Event.for_year == CurrentYear).count()

    def is_IntervenantOnYear(self, year=CurrentYear):
        """ This property will return if User do an event on specified year """
        return DBSession.query(Event).join(User_Event) \
            .filter(User_Event.user_uid == self.uid) \
            .filter(Event.for_year == year).count()

    @property
    def is_crew(self, year=CurrentYear):
        """ This property will return if User subscribe orga task on specified year """
        orga_checked = DBSession.query(User, Sejour.orga_part) \
            .outerjoin(Sejour) \
            .filter(Sejour.for_year == year) \
            .filter(User.uid == self.uid).first()
        if orga_checked:
            return orga_checked
        else:
            return False

    def year_events(self, EventType='All', year=CurrentYear):
        if EventType == 'All':
            return list(filter(lambda e: e.for_year == year, self.events))
        else:
            return list(filter(lambda e: e.for_year == year and e.event_type == EventType, self.events))

    @property
    def my_hash(self):
        m = hashlib.sha1()
        m.update("Nobody inspects ".encode('utf-8'))
        if self.nom:
            m.update(self.nom.encode('utf-8')) # unicode.encode(self.nom, 'utf8'))
        if self.pseudo:
            m.update(self.pseudo.encode('utf-8')) # unicode.encode(self.pseudo, 'utf8'))
        if self.prenom:
            m.update(self.prenom.encode('utf-8')) # unicode.encode(self.prenom, 'utf8'))
        m.update(" the spammish repetition".encode('utf-8'))
        return m.hexdigest()

    @property
    def Photos(self):
        return DBSession.query(Media.filename) \
            .filter(Media.media_table == 'users') \
            .filter(Media.media_type == 'Image') \
            .filter(Media.link_id == self.user_id).all()

    @property
    def PhotosLinks(self):
        from .upload import MediaPath
        return MediaPath().get_list('users', self.uid)

    @property
    def PhotosThumb(self):
        from .upload import MediaPath
        return MediaPath().get_thumb('users', self.uid)

    def verify_password(self, password):
        if not argon2.identify(self.password):  # Update existing clear-text password
            self.password = argon2.using(rounds=4).hash(self.password)
            DBSession.merge(self)

        return argon2.verify(password, self.password)


class TiersOpt(Base):
    __tablename__ = 'tiers_opt'
    uid = Column(Integer, primary_key=True)
    entity_type = Column(Unicode(80), nullable=False)
    entity_subtype = Column(Unicode(80))
    entity_role = Column(Unicode(80))

    @property
    def slug_entity_type(self):
        return slugify(self.entity_type)

    @property
    def slug_entity_subtype(self):
        return slugify(self.entity_subtype)

    @classmethod
    def get_entity_type(cls):
        return DBSession.query(cls, func.count(Tiers.ent_type).label('count')) \
            .outerjoin(Tiers) \
            .group_by(cls.entity_type).all()

    @classmethod
    def get_entity_sub_type(cls, entity_type):
        return DBSession.query(cls, func.count(Tiers.ent_type).label('count')) \
            .outerjoin(Tiers) \
            .filter(cls.entity_type == entity_type) \
            .group_by(cls.entity_subtype).all()

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.uid == uid).first()


class Tiers(Base):
    __tablename__ = 'tiers'
    uid = Column(Integer, primary_key=True)
    tiers_id = Column(Integer)
    name = Column(Unicode(100), nullable=False)
    slug = Column(Unicode(100))
    description = Column(UnicodeText)
    website = Column(Unicode(100))
    tiers_type = Column(Integer, ForeignKey('tiers_opt.uid'), default=1)
    created = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)
    # relations
    ent_type = relationship('TiersOpt')
    # members      = relationship('User', secondary='user_tiers_link' )
    members = relationship(User,
                           secondary='user_tiers_link',
                           backref=backref('associate', uselist=False),
                           lazy='dynamic')
    creator_id = Column(Integer)
    membership = relationship('User_Tiers', backref="matching_tiers")
    roles = relationship('Role_Tiers', backref="roles_tiers")  # secondary='role_tiers_link' )

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.uid == uid).first()

    @classmethod
    def by_slug(cls, slug):
        return DBSession.query(cls).filter(cls.slug == slug).first()

    @property
    def get_entity_type(self):
        return DBSession.query(TiersOpt) \
            .filter(TiersOpt.uid == self.tiers_type).first()

    @property
    def logo(self):
        return DBSession.query(Media) \
            .filter(Media.media_table == 'tiers') \
            .filter(Media.media_type == 'Image') \
            .filter(Media.link_id == self.uid)

    @property
    def DocLinks(self):
        from .upload import MediaPath
        return zip(sorted(MediaPath().get_list('tiers', self.uid, 'Other')),
                   sorted(MediaPath().get_thumb('tiers', self.uid, 'Other'))
                   )

    @property
    def PhotosLinks(self):
        from .upload import MediaPath
        return MediaPath().get_list('tiers', self.uid, 'Image')

    @property
    def ThumbLinks(self):
        from .upload import MediaPath
        return MediaPath().get_thumb('tiers', self.uid)


class Role_Tiers(Base):
    """ Créer le lien entre le tiers et son rôle dans l'évenement en fonction de l'année"""
    __tablename__ = 'role_tiers_link'
    uid_role = Column(Integer, primary_key=True)
    year_uid = Column(Integer, ForeignKey('jm2l_year.year_uid'), default=CurrentYear)
    tiers_uid = Column(Integer, ForeignKey('tiers.uid'))
    tiers = relationship(Tiers, backref=backref("roles_assoc"))
    tiers_role = Column(Enum('Exposant', 'Sponsor', 'Donateur'))
    event_uid = Column(Integer, default=None)  # Optionnal link with Event


class User_Tiers(Base):
    """ Créer le lien entre la personne et le tiers en fonction de l'année"""
    __tablename__ = 'user_tiers_link'
    uid_tiers = Column(Integer, primary_key=True)
    year_uid = Column(Integer, ForeignKey('jm2l_year.year_uid'), default=CurrentYear)
    tiers_uid = Column(Integer, ForeignKey('tiers.uid'))
    tiers = relationship(Tiers, backref=backref("users_assoc"))
    user_uid = Column(Integer, ForeignKey('users.uid'))
    user = relationship(User, backref=backref("tiers_assoc"))
    role = Column(Unicode(80))


class Media(Base):
    __tablename__ = 'medias'
    media_id = Column(Integer, primary_key=True)
    for_year = Column(Integer, ForeignKey('jm2l_year.year_uid'))
    media_table = Column(Enum('users', 'tiers', 'place', 'salle', 'RIB', 'Justif', 'event'))
    media_type = Column(Enum('Image', 'Video', 'Pres', 'Document'))
    link_id = Column(Integer)
    mime_type = Column(Unicode(20))
    size = Column(Integer)
    width = Column(Integer)
    height = Column(Integer)
    length = Column(Integer)
    filename = Column(UnicodeText)
    created = Column(DateTime, default=datetime.datetime.now)

    @property
    def get_path(self):
        # return '/upload/%s/%s/%s' % (self.media_type, self.media_table, self.filename)
        return '/resources/%s/%s/%s' % (self.for_year, self.media_type, self.filename)


class SallePhy(Base):
    """ Représente une salle dans les locaux """
    __tablename__ = 'phy_salle'
    uid = Column(Integer, primary_key=True)
    name = Column(Unicode(40))  # Numéro de salle vu de polytech
    slug = Column(Unicode(40))
    description = Column(UnicodeText)  # Description du matériel disponible
    nb_places = Column(Integer, default=0)  # Nombre de places assises

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.uid == uid).first()

    @property
    def PhotosLinks(self):
        from .upload import MediaPath
        return MediaPath().get_list('salle', self.uid, 'Image')


class Salles(Base):
    __tablename__ = 'salle'
    salle_id = Column(Integer, primary_key=True)
    phy_salle_id = Column(Integer, ForeignKey('phy_salle.uid'))
    year_uid = Column(Integer, ForeignKey('jm2l_year.year_uid'), default=CurrentYear)
    name = Column(Unicode(40))
    place_type = Column(Enum('Conference', 'Stand', 'Atelier', 'Table ronde', 'MAO', 'Repas', 'Autres'))
    description = Column(UnicodeText)  # Description du matériel disponible
    created = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)

    phy = relationship(SallePhy)

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.salle_id == uid).first()


class Place(Base):
    __tablename__ = 'place'
    place_id = Column(Integer, primary_key=True)
    usage = Column(Boolean, default=False)  # By Default / Extended
    place_type = Column(Enum('Aeroport', 'Gare', 'JM2L', \
                             'Hotel', 'Habitant', 'Restaurant', 'Autres'))
    display_name = Column(Unicode(20))
    name = Column(Unicode(80))
    slug = Column(Unicode(80))
    specific = Column(Unicode(80))  # eg Terminal 2
    gps_coord = Column(Unicode(30))
    adresse = Column(Unicode(100))
    codePostal = Column(Unicode(5))
    ville = Column(Unicode(40))
    website = Column(Unicode(100))
    description = Column(UnicodeText)
    created_by = Column(Integer, ForeignKey('users.user_id'))
    created = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.place_id == uid).first()

    @classmethod
    def get_list(cls, All=False):
        if All:
            return DBSession.query(cls).all()
        else:
            return DBSession.query(cls).filter(cls.usage == True).all()


class Itineraire(Base):
    __tablename__ = 'itineraire'
    itin_id = Column(Integer, primary_key=True)
    start_place = Column(Integer, ForeignKey('place.place_id'))  # Place link
    arrival_place = Column(Integer, ForeignKey('place.place_id'))  # Place link
    distance = Column(Integer)
    duration = Column(Integer)
    price = Column(Integer)
    tr_pied = Column(Boolean, default=False)
    tr_velo = Column(Boolean, default=False)
    tr_moto = Column(Boolean, default=False)
    tr_voiture = Column(Boolean, default=False)
    tr_bus = Column(Boolean, default=False)
    tr_taxi = Column(Boolean, default=False)
    tr_avion = Column(Boolean, default=False)
    description = Column(UnicodeText)
    created_by = Column(Integer, ForeignKey('users.user_id'))  # User link
    created = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)
    # relations
    start = relationship(Place, foreign_keys=[start_place])
    arrival = relationship(Place, foreign_keys=[arrival_place])


class Exchange_Cat(Base):
    __tablename__ = 'exchange_category'
    cat_id = Column(Integer, primary_key=True)
    exch_type = Column(Enum('H', 'C', 'M'))  # Heberg, Co-voit, Materiel
    exch_subtype = Column(Unicode(80))
    description = Column(UnicodeText)


class Exchange(Base):
    __tablename__ = 'exchanges'
    exch_id = Column(Integer, primary_key=True)
    for_year = Column(Integer, ForeignKey('jm2l_year.year_uid'))  # link JM2L_Year
    exch_done = Column(Boolean, default=False)
    exch_state = Column(Enum('Ask', 'Proposal'))
    exch_type = Column(Enum('H', 'C', 'M'))  # Heberg, Co-Voit, Materiel
    exch_categ = Column(Integer, ForeignKey('exchange_category.cat_id'))  # Exchange_Cat link
    # Users
    asker_id = Column(Integer, ForeignKey('users.uid'))  # User link
    provider_id = Column(Integer, ForeignKey('users.uid'))  # User link
    start_time = Column(DateTime, default=datetime.datetime.now)
    end_time = Column(DateTime, default=datetime.datetime.now)
    # Co-voiturage
    itin_id = Column(Integer, ForeignKey('itineraire.itin_id'))  # Itineraire link
    # Hebergement
    place_id = Column(Integer, ForeignKey('place.place_id'))  # Place link
    # Materiel
    duration = Column(Integer)
    description = Column(UnicodeText)
    pictures = Column(Unicode(80))
    created_by = Column(Integer)  # User link
    created = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)
    # relations
    Category = relationship(Exchange_Cat, backref="exchanges")
    Itin = relationship(Itineraire, backref="exchanged")
    asker = relationship(User, foreign_keys=[asker_id], backref="asked")
    provider = relationship(User, foreign_keys=[provider_id], backref="provided")

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls).filter(cls.exch_id == uid).first()

    @classmethod
    def get_counters(cls):
        return DBSession.query(cls.exch_state, cls.exch_type, cls.exch_done, func.count(cls.exch_id)) \
            .filter(cls.for_year == CurrentYear) \
            .group_by(cls.exch_state, cls.exch_type, cls.exch_done)

    @classmethod
    def get_my_counters(cls, uid):
        return DBSession.query(cls.exch_state, cls.exch_type, cls.exch_done, func.count(cls.exch_id)) \
            .filter(cls.for_year == CurrentYear) \
            .filter(or_(cls.asker_id == uid, cls.provider_id == uid)) \
            .group_by(cls.exch_state, cls.exch_type, cls.exch_done)

    @classmethod
    def get_overview(cls, uid):
        # Build a Dic with all exchange to save database access
        DicResult = {}
        for extype in ['F', 'C', 'H', 'M']:
            DicResult[extype] = {}
            for exstate in ['Ask', 'Proposal', 'Missing', 'Agree']:
                DicResult[extype][exstate] = []
            DicResult[extype]['Counters'] = {'AllAsk': 0, 'AllProp': 0, 'AllAgree': 0}
        Query = DBSession.query(cls) \
            .filter(cls.for_year == CurrentYear) \
            .order_by(cls.start_time).all()
        for item in Query:
            if item.exch_done:
                DicResult[item.exch_type]['Counters']['AllAgree'] += 1
            if item.exch_state == 'Ask':
                DicResult[item.exch_type]['Counters']['AllAsk'] += 1
            if item.exch_state == 'Proposal':
                DicResult[item.exch_type]['Counters']['AllProp'] += 1
            if item.asker_id == uid or item.provider_id == uid:
                if item.asker_id == uid and item.exch_state == 'Ask':
                    DicResult[item.exch_type]['Ask'].append(item)
                if item.provider_id == uid and item.exch_state == 'Ask':
                    DicResult[item.exch_type]['Proposal'].append(item)
                if item.asker_id == uid and item.exch_state == 'Proposal':
                    DicResult[item.exch_type]['Ask'].append(item)
                if item.provider_id == uid and item.exch_state == 'Proposal':
                    DicResult[item.exch_type]['Proposal'].append(item)
                if item.exch_done:
                    DicResult[item.exch_type]['Agree'].append(item)
            else:
                DicResult[item.exch_type]['Missing'].append(item)

        return DicResult

    @classmethod
    def get_pub_list(cls, exch_type):
        return DBSession.query(cls).filter(cls.for_year == CurrentYear and cls.exch_state in ['Ask', 'Proposal']) \
            .filter(cls.exch_type == '%s' % exch_type) \
            .filter(cls.exch_done == False) \
            .all()

    @classmethod
    def get_my_list(cls, uid, exch_type):
        DicResult = {}
        DicResult['Ask'] = DBSession.query(cls) \
            .filter(cls.for_year == CurrentYear) \
            .filter(or_(cls.asker_id == uid, cls.provider_id == uid)) \
            .filter(cls.exch_type == '%s' % exch_type) \
            .filter(cls.exch_state == 'Ask') \
            .order_by(cls.start_time).all()
        DicResult['Proposal'] = DBSession.query(cls) \
            .filter(cls.for_year == CurrentYear) \
            .filter(or_(cls.asker_id == uid, cls.provider_id == uid)) \
            .filter(cls.exch_type == '%s' % exch_type) \
            .filter(cls.exch_state == 'Proposal') \
            .order_by(cls.start_time).all()
        return DicResult


class Sejour(Base):
    __tablename__ = 'sejour'
    sej_id = Column(Integer, primary_key=True)
    user_id = Column(Integer, ForeignKey('users.uid'))  # User link
    for_year = Column(Integer, ForeignKey('jm2l_year.year_uid'))  # link JM2L_Year
    arrival_time = Column(DateTime)
    arrival_place = Column(Integer, ForeignKey('place.place_id'))  # Place link
    arrival_check = Column(Integer, default=0)
    arrival_text = Column(Unicode(100))
    depart_time = Column(DateTime)
    depart_place = Column(Integer, ForeignKey('place.place_id'))  # Place link
    depart_check = Column(Integer, default=0)
    depart_text = Column(Unicode(100))
    repas = Column(Integer)
    repas_allerg = Column(Unicode(100))
    repas_contr = Column(Unicode(100))
    orga_part = Column(Integer, default=0)
    travel_detail = Column(UnicodeText)
    created = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)

    @classmethod
    def by_user(cls, uid, year):
        return DBSession.query(cls) \
            .filter(cls.user_id == uid) \
            .filter(cls.for_year == year) \
            .first()


class Event(Base):
    __tablename__ = 'events'
    uid = Column(Integer, primary_key=True)
    salle_uid = Column(Integer, ForeignKey('salle.salle_id'))
    event_uid = Column(Integer)
    for_year = Column(Integer, ForeignKey('jm2l_year.year_uid'))  # link JM2L_Year
    name = Column(Unicode(100), nullable=False)
    slug = Column(Unicode(100))
    event_type = Column(Enum('Conference', 'Stand', 'Atelier', 'Table ronde', 'MAO', 'Repas', 'Autres'))
    start_time = Column(DateTime, default=datetime.datetime.now)
    end_time = Column(DateTime, default=datetime.datetime.now)
    description = Column(UnicodeText)
    created = Column(DateTime, default=datetime.datetime.now)
    last_change = Column(DateTime, default=datetime.datetime.now)
    intervenants = relationship(User,
                                secondary='user_event_link',
                                backref=backref('participate', uselist=False),
                                lazy='subquery')
    interventions = relationship(User_Event, backref="matching_events")
    Salle = relationship(Salles, backref='allevents')

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(cls) \
            .filter(cls.uid == uid).first()

    @classmethod
    def by_slug(cls, slug, year=None):
        if not year is None:
            return DBSession.query(cls) \
                .filter(cls.for_year == year) \
                .filter(cls.slug == slug).first()
        else:
            return DBSession.query(cls) \
                .filter(cls.slug == slug).first()

    def get_linked_tiers(self):
        ListLink = DBSession.query(Role_Tiers.tiers_uid) \
            .filter(Role_Tiers.year_uid == self.for_year) \
            .filter(Role_Tiers.tiers_role == "Exposant") \
            .filter(Role_Tiers.event_uid == self.uid)
        return DBSession.query(Tiers).filter(Tiers.uid.in_(ListLink))

    @property
    def video(self):
        return DBSession.query(Media) \
            .filter(Media.media_table == 'event') \
            .filter(Media.media_type == 'Video') \
            .filter(Media.link_id == self.uid)

    @property
    def presentation(self):
        return DBSession.query(Media) \
            .filter(Media.media_table == 'event') \
            .filter(Media.media_type == 'Pres') \
            .filter(Media.link_id == self.uid)

    @property
    def created_in_words(self):
        return time_ago_in_words(self.created)


class Entry(Base):
    __tablename__ = 'entries'
    id = Column(Integer, primary_key=True)
    active = Column(Integer, default=True)
    title = Column(Unicode(255), unique=True, nullable=False)
    body = Column(UnicodeText, default=u'')
    created = Column(DateTime, default=datetime.datetime.now)
    edited = Column(DateTime, default=datetime.datetime.now)

    @classmethod
    def all(cls):
        return DBSession.query(Entry).order_by(sa.desc(Entry.created))

    @classmethod
    def by_id(cls, uid):
        return DBSession.query(Entry).filter(Entry.id == uid).first()

    @property
    def slug(self):
        return urlify(self.title)

    @property
    def created_in_words(self):
        return time_ago_in_words(self.created)

    @classmethod
    def get_paginator(cls, request, page=1):
        page_url = PageURL_WebOb(request)
        return Page(Entry.all(), page, url=page_url, items_per_page=5)


# class Seances(Base):
#    __tablename__ = 'seances'
def get_user(request):
    # the below line is just an example, use your own method of
    # accessing a database connection here (this could even be another
    # request property such as request.db, implemented using this same
    # pattern).
    userid = unauthenticated_userid(request)
    if userid is not None:
        # this should return None if the user doesn't exist
        # in the database
        return DBSession.query(User).filter(User.uid == userid).first()


def get_sponsors(request, Year):
    if Year:
        return DBSession.query(Tiers) \
            .join(Role_Tiers, Role_Tiers.tiers_uid == Tiers.uid) \
            .filter(Role_Tiers.tiers_role == 'Sponsor') \
            .filter(Role_Tiers.year_uid == Year)
    else:
        return DBSession.query(Tiers) \
            .join(Role_Tiers, Role_Tiers.tiers_uid == Tiers.uid) \
            .filter(Role_Tiers.tiers_role == 'Sponsor')


def get_exposants(request, Year):
    if Year:
        return DBSession.query(Tiers) \
            .join(Role_Tiers, Role_Tiers.tiers_uid == Tiers.uid) \
            .filter(Role_Tiers.tiers_role == 'Exposant') \
            .filter(Role_Tiers.year_uid == Year)
    else:
        return DBSession.query(Tiers) \
            .join(Role_Tiers, Role_Tiers.tiers_uid == Tiers.uid) \
            .filter(Role_Tiers.tiers_role == 'Exposant')