class WaterVolume(Base):
__lazy_options__ = {}
__tablename__ = 'water_volume'
id = Column(Integer, primary_key=True)
datetime = Column(DateTime, auto_now=True, nullable=False)
volume = Column(Integer, nullable=False) # cL
class Tag(db.Model):
id = Column(
db.Integer,
primary_key=True,
)
name = Column(db.String(30), nullable=False, info={'label': 'Name'})
class Departement(db.Model, MarshalMixin, FilterOr404Mixin):
id = Column(db.Integer, primary_key=True)
nom = Column(db.String(255), label='Nom')
numero = Column(db.String(3), label='Numero')
def __str__(self):
return '%s' % (self.numero)
class CuboidTank(Tank):
__tablename__ = 'cuboid_tank'
__lazy_options__ = {}
id = Column(Integer, ForeignKey('tank.id'), primary_key=True)
length = Column(
Integer,
min=1,
info={'label': 'Length (mm)'},
nullable=False,
)
width = Column(
Integer,
min=1,
info={'label': 'Width (mm)'},
nullable=False,
)
height = Column(
Integer,
min=1,
info={'label': 'Height (mm)'},
nullable=False,
)
__mapper_args__ = {
'polymorphic_identity': __tablename__,
}
is_cuboid = True
@property
def volume(self):
return self.height * self.width * self.length
class User(self.Model):
__tablename__ = 'user'
__lazy_options__ = options
id = Column(sa.Integer, primary_key=True)
is_active = Column(sa.Boolean)
nullable_boolean = Column(sa.Boolean, nullable=True)
is_admin = Column(sa.Boolean, default=True)
class Character(db.Model):
id = Column(db.Integer, primary_key=True)
name = Column(db.Unicode)
actor_id = Column(db.Integer, db.ForeignKey('actor.id'))
actor = db.relationship(
'Actor',
backref=db.backref('actors', lazy='dynamic'),
)
series_id = Column(db.Integer, db.ForeignKey('series.id'))
series = db.relationship(
'Series',
backref=db.backref('characters', lazy='dynamic'),
)
class Tank(Base):
__tablename__ = 'tank'
id = Column(Integer, primary_key=True)
type = Column(String(50))
__mapper_args__ = {
'polymorphic_identity': __tablename__,
'polymorphic_on': type
}
is_cuboid = False
is_cylindric = False
@property
def volume(self):
raise NotImplementedError()
class User(self.Model):
__tablename__ = 'user'
__lazy_options__ = options
id = Column(Integer, primary_key=True)
name = Column(Unicode(255))
age = Column(Integer, info={'min': 13, 'max': 120}, default=16)
is_active = Column(Boolean)
is_admin = Column(Boolean, default=True)
hobbies = Column(Unicode(255), default=u'football')
favorite_hobbies = Column(Unicode(255),
default=lambda ctx:
(ctx.current_parameters['hobbies']
if ctx.current_parameters['hobbies'] is
not None else u'football'))
favorite_buddy = Column(Unicode(255), default=u'Örrimörri')
created_at = Column(sa.DateTime, info={'auto_now': True})
description = Column(sa.UnicodeText)
class ZUPC(db.Model, MarshalMixin, CacheableMixin):
cache_label = 'zupc'
query_class = query_callable()
id = Column(db.Integer, primary_key=True)
departement_id = Column(db.Integer, db.ForeignKey('departement.id'))
nom = Column(db.String(255), label='Nom')
insee = Column(db.String(), nullable=True)
shape = Column(Geography(geometry_type='MULTIPOLYGON', srid=4326,
spatial_index=False), label='Geography of the shape')
departement = db.relationship('Departement',
backref=db.backref('departements'), lazy='joined')
parent_id = Column(db.Integer, db.ForeignKey('ZUPC.id'))
parent = db.relationship('ZUPC', remote_side=[id], lazy='joined')
active = Column(db.Boolean, default=False)
__geom = None
__preped_geom = None
__bounds = None
def __repr__(self):
return '<ZUPC %r>' % str(self.id)
def __str__(self):
return self.nom
@property
def geom(self):
if self.__geom is None:
self.__geom = to_shape(self.shape)
return self.__geom
@property
def preped_geom(self):
if self.__preped_geom is None:
self.__preped_geom = prep(self.geom)
return self.__preped_geom
@property
def bounds(self):
if not self.__bounds:
self.__bounds = self.geom.bounds
return self.__bounds
@property
def bottom(self):
return self.bounds[1]
@property
def left(self):
return self.bounds[0]
@property
def top(self):
return self.bounds[3]
@property
def right(self):
return self.bounds[2]
class Constructor(db.Model, AsDictMixin, MarshalMixin):
id = Column(db.Integer, primary_key=True)
name = Column(db.String,
label=u'Dénomination commerciale de la marque',
description=u'Dénomination commerciale de la marque',
unique=True)
def __init__(self, name=None):
db.Model.__init__(self)
if isinstance(name, self.__class__):
self.name = name.name
else:
self.name = name
def __repr__(self):
return '<Constructor %r>' % unicode(self.name)
def __eq__(self, other):
return self.__repr__() == other.__repr__()
def __ne__(self, other):
return not self.__eq__(other)
class BlogPost(db.Model):
__lazy_options__ = {}
id = Column(
db.Integer,
primary_key=True,
)
title = Column(
db.Text,
info={'label': 'Title'},
)
slug = Column(
db.Text,
info={'label': 'Slug'},
nullable=False,
)
rendered_content = Column(
db.Text,
nullable=False,
)
raw_content = Column(
db.Text,
info={'label': 'Article'},
nullable=False,
)
datetime_added = Column(
db.DateTime,
server_default=func.now(),
nullable=False,
)
tags = db.relationship('Tag',
secondary=tags,
backref=db.backref('posts', lazy='dynamic'))
def render(self):
self.rendered_content = render_blocks(
json.loads(self.raw_content)['data'])
def url(self, external=False):
return url_for('blag.post_details',
year=self.year,
slug=self.slug,
_external=external)
@property
def year(self):
return self.datetime_added.year
class User(db.Model, UserMixin):
"""Flask-Security User model."""
id = Column(db.Integer, primary_key=True)
created = Column(db.DateTime, auto_now=True)
email = Column(db.Unicode)
password = Column(db.String(255))
active = Column(db.Boolean, default=True, nullable=False)
confirmed_at = Column(db.DateTime)
roles = db.relationship(
'Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'),
)
class User(self.Model):
__tablename__ = 'user'
__lazy_options__ = options
id = Column(sa.Integer, primary_key=True)
name = Column(sa.Unicode(255))
hobbies = Column(sa.Unicode(255), default=u'football')
hobbies2 = Column(
sa.Unicode(255), default=u'ice-hockey', server_default=u''
)
favorite_hobbies = Column(sa.Unicode(255), default=lambda ctx: (
ctx.current_parameters['hobbies']
if ctx.current_parameters['hobbies'] is not None
else u'football'
))
favorite_buddy = Column(sa.Unicode(255), default=u'Örrimörri')
description = Column(sa.UnicodeText)
class Config(Base):
__tablename__ = 'config'
__lazy_options__ = {}
id = Column(Integer, primary_key=True)
water_volume_max_delta = Column(
Integer,
min=0,
info={'label': 'Water volume max delta (mm3)'},
nullable=False,
)
min_water_volume = Column(
Integer,
min=0,
info={'label': 'Min water volume (mm3)'},
nullable=False,
)
max_water_volume = Column(
Integer,
min=0,
info={'label': 'Max water volume (mm3)'},
nullable=False,
)
well_filling_delay = Column(
Integer,
min=0,
info={'label': 'Well filling delay (s)'},
nullable=False,
)
min_flow_in = Column(
Integer,
min=0,
info={'label': 'Min flow in (mm3/s)'},
nullable=False,
)
tank = relationship(Tank, lazy='subquery')
tank_id = Column(
Integer,
ForeignKey('{}.id'.format(Tank.__tablename__)),
info={'label': 'Tank'},
nullable=False,
)
class Driver(HistoryMixin, db.Model, AsDictMixin, FilterOr404Mixin):
@declared_attr
def added_by(cls):
return Column(db.Integer, db.ForeignKey('user.id'))
def __init__(self):
db.Model.__init__(self)
HistoryMixin.__init__(self)
id = Column(db.Integer, primary_key=True)
last_name = Column(db.String(255),
label='Nom',
description=u'Nom du conducteur')
first_name = Column(db.String(255),
label=u'Prénom',
description=u'Prénom du conducteur')
birth_date = Column(
db.Date(),
label=u'Date de naissance (format année-mois-jour)',
description=u'Date de naissance (format année-mois-jour)')
professional_licence = Column(
db.String(),
label=u'Numéro de la carte professionnelle',
description=u'Numéro de la carte professionnelle')
departement_id = Column(db.Integer,
db.ForeignKey('departement.id'),
nullable=True)
departement = db.relationship('Departement',
backref='vehicle',
lazy="joined")
@classmethod
def can_be_listed_by(cls, user):
return super(Driver,
cls).can_be_listed_by(user) or user.has_role('prefecture')
def __eq__(self, other):
return self.__repr__() == other.__repr__()
def __ne__(self, other):
return not self.__eq__(other)
def __repr__(self):
return '<drivers %r>' % unicode(self.id)
class Hike(db.Model):
__lazy_options__ = {}
METHODS = [
('ski', 'Ski'),
('foot', 'Foot'),
('crampons', 'Crampons'),
('climb', 'Climb'),
('via ferrata', 'Via Ferrata'),
('bike', 'Bike'),
('kayak', 'Kayak'),
]
id = Column(db.Integer, primary_key=True)
destination_id = Column(db.Integer,
db.ForeignKey(HikeDestination.id),
nullable=False)
destination = db.relationship(HikeDestination, backref=db.backref('hikes'))
date = Column(db.Date, nullable=True, server_default=func.now())
method = Column(ChoiceType(METHODS), nullable=False)
notes = Column(db.Text, nullable=False, server_default='')
created_at = Column(db.DateTime, nullable=False, server_default=func.now())
__table_args__ = (CheckConstraint("method in (%s)" %
','.join("'%s'" % method[0]
for method in METHODS)), )
class HikeDestination(db.Model):
id = Column(db.Integer, primary_key=True)
name = Column(db.String(100), nullable=False)
altitude = Column(db.Integer, nullable=True) # TODO: Require if is_summit
high_point_coord = Column(
Geometry('POINT'),
nullable=False,
info={
'form_field_class': TextField,
# 'validators': CoordinateValidator(), # TODO: Ensure input is validated and casted to something understandable by PostGIS
}) # TODO: Require if summit
is_summit = Column(db.Boolean, nullable=False, server_default='t')
created_at = Column(db.DateTime, nullable=False, server_default=func.now())
def to_json(self):
geojson = json.loads(
db.session.scalar(self.high_point_coord.ST_AsGeoJSON()))
return {
'name': self.name,
'coordinates': geojson['coordinates'],
}
def __str__(self):
return '%s (%d)' % (self.name, self.altitude)
class VehicleDescription(HistoryMixin, CacheableMixin, db.Model, AsDictMixin):
@declared_attr
def added_by(cls):
return Column(db.Integer, db.ForeignKey('user.id'))
cache_label = 'taxis'
query_class = query_callable()
def __init__(self, vehicle_id, added_by):
db.Model.__init__(self)
HistoryMixin.__init__(self)
self.vehicle_id = vehicle_id
self.added_by = added_by
id = Column(db.Integer, primary_key=True)
model_id = Column(db.Integer, db.ForeignKey("model.id"))
__model = db.relationship('Model', lazy='joined')
constructor_id = Column(db.Integer, db.ForeignKey("constructor.id"))
__constructor = db.relationship('Constructor', lazy='joined')
model_year = Column(db.Integer,
label=u'Année',
nullable=True,
description=u'Année de mise en production du véhicule')
engine = Column(db.String(80),
label=u'Motorisation',
nullable=True,
description=u'Motorisation du véhicule, champ P3')
horse_power = Column(
db.Float(),
label=u'Puissance',
nullable=True,
description=u'Puissance du véhicule en chevaux fiscaux')
relais = Column(db.Boolean,
label=u'Relais',
default=False,
nullable=True,
description=u'Est-ce un véhicule relais')
horodateur = Column(db.String(255),
label=u'Horodateur',
nullable=True,
description=u'Modèle de l\'horodateur')
taximetre = Column(db.String(255),
label=u'Taximètre',
nullable=True,
description=u'Modèle du taximètre')
date_dernier_ct = Column(
db.Date(),
label=u'Date du dernier CT (format année-mois-jour)',
description=u'Date du dernier contrôle technique')
date_validite_ct = Column(
db.Date(),
label=u'Date de la fin de validité du CT (format année-mois-jour)',
description=u'Date de fin de validité du contrôle technique')
special_need_vehicle = Column(
db.Boolean,
name='special_need_vehicle',
label=u'Véhicule spécialement aménagé pour PMR ',
nullable=True)
type_ = Column(Enum('sedan',
'mpv',
'station_wagon',
'normal',
name='vehicle_type_enum'),
label='Type',
nullable=True)
luxury = Column(db.Boolean, name='luxury', label='Luxe ?', nullable=True)
credit_card_accepted = Column(db.Boolean,
name='credit_card_accepted',
label=u'Carte bancaire acceptée ?',
nullable=True)
nfc_cc_accepted = Column(
db.Boolean,
name='nfc_cc_accepted',
label=u'Paiement sans contact sur carte bancaire accepté ?',
nullable=True)
amex_accepted = Column(db.Boolean,
name='amex_accepted',
label=u'AMEX acceptée ?',
nullable=True)
bank_check_accepted = Column(db.Boolean,
name='bank_check_accepted',
label=u'Chèque bancaire accepté ?',
nullable=True)
fresh_drink = Column(db.Boolean,
name='fresh_drink',
label=u'Boisson fraiche ?',
nullable=True)
dvd_player = Column(db.Boolean,
name='dvd_player',
label='Lecteur DVD ?',
nullable=True)
tablet = Column(db.Boolean,
name='tablet',
label='Tablette ?',
nullable=True)
wifi = Column(db.Boolean,
name='wifi',
label=u'Wifi à bord ?',
nullable=True)
baby_seat = Column(db.Boolean,
name='baby_seat',
label=u'Siège bébé ?',
nullable=True)
bike_accepted = Column(db.Boolean,
name='bike_accepted',
label=u'Transport de vélo',
nullable=True)
pet_accepted = Column(db.Boolean,
name='pet_accepted',
label=u'Animaux de compagnie acceptés ?',
nullable=True)
air_con = Column(db.Boolean,
name='air_con',
label=u'Véhicule climatisé',
nullable=True)
electronic_toll = Column(db.Boolean,
name='electronic_toll',
label=u'Véhicule équipé du télépéage',
nullable=True)
gps = Column(db.Boolean,
name='gps',
label=u'Véhicule équipé d\'un GPS',
nullable=True)
cpam_conventionne = Column(db.Boolean,
name='cpam_conventionne',
label=u'Conventionné assurance maladie',
nullable=True)
every_destination = Column(db.Boolean,
name='every_destination',
label=u'Toute destination',
nullable=True)
color = Column(db.String(255),
name='color',
label='Couleur : ',
nullable=True)
vehicle_id = Column(db.Integer, db.ForeignKey('vehicle.id'))
UniqueConstraint('vehicle_id', 'added_by', name="uq_vehicle_description")
_status = Column(Enum(*status_vehicle_description_enum,
name='status_taxi_enum'),
nullable=True,
default='free',
name='status')
nb_seats = Column(
db.Integer,
name='nb_seats',
description=u'Nombre de places assises disponibles pour les voyageurs',
label=u'Nombre de places')
__table_args__ = (db.UniqueConstraint('vehicle_id',
'added_by',
name="_uq_vehicle_description"), )
@property
def status(self):
return self._status
@status.setter
def status(self, value):
assert value is None or value == 'None' or value in status_vehicle_description_enum,\
'{} is not a valid status, (valid statuses are {})'\
.format(value, status_vehicle_description_enum)
self._status = value
from .taxis import Taxi
operator = User.query.get(self.added_by)
for t in Taxi.query.join(Taxi.vehicle,
aliased=True).filter_by(id=self.vehicle_id):
t.set_avaibility(operator.email, self._status)
@classmethod
def to_exclude(cls):
return list(HistoryMixin.to_exclude()) + ['status']
@property
def constructor(self):
return self.__constructor.name
@constructor.setter
def constructor(self, name):
self.__constructor = Constructor(name)
@property
def model(self):
return self.__model.name
@model.setter
def model(self, name):
self.__model = Model(name)
@property
def characteristics(self):
return VehicleDescription.get_characs(lambda o, f: getattr(o, f), self)
@staticmethod
def get_characs(getattr_, obj):
fields = [
'special_need_vehicle', 'every_destination', 'gps',
'electronic_toll', 'air_con', 'pet_accepted', 'bike_accepted',
'baby_seat', 'wifi', 'tablet', 'dvd_player', 'fresh_drink',
'amex_accepted', 'bank_check_accepted', 'nfc_cc_accepted',
'credit_card_accepted', 'luxury'
]
return list(compress(fields, map(lambda f: getattr_(obj, f), fields)))
class Vehicle(CacheableMixin, db.Model, AsDictMixin, MarshalMixin,
FilterOr404Mixin):
cache_label = 'taxis'
query_class = query_callable()
id = Column(db.Integer, primary_key=True)
licence_plate = Column(db.String(80),
label=u'Immatriculation',
description=u'Immatriculation du véhicule',
unique=True)
descriptions = db.relationship("VehicleDescription", lazy='joined')
def __init__(self, licence_plate=None):
if isinstance(licence_plate, self.__class__):
self.licence_plate = licence_plate.licence_plate
else:
self.licence_plate
@classmethod
def marshall_obj(cls, show_all=False, filter_id=False, level=0, api=None):
if level >= 2:
return {}
return_ = super(Vehicle, cls).marshall_obj(show_all,
filter_id,
level=level + 1,
api=api)
dict_description = VehicleDescription.marshall_obj(show_all,
filter_id,
level=level + 1,
api=api)
for k, v in dict_description.items():
dict_description[k].attribute = 'description.{}'.format(k)
return_.update(dict_description)
return_.update({
"model":
fields.String(attribute="description.model"),
"constructor":
fields.String(attribute="description.constructor")
})
if not filter_id:
return_["id"] = fields.Integer()
return return_
@property
def description(self):
return self.get_description()
def get_description(self, user=None):
if not user:
user = current_user
returned_description = None
for description in self.descriptions:
if description.added_by == user.id:
returned_description = description
return returned_description
@property
def model(self):
return self.description.model if self.description else None
@property
def constructor(self):
return self.description.constructor.name if self.description else None
@property
def model_year(self):
return self.description.model_year if self.description else None
@property
def engine(self):
return self.description.engine if self.description else None
@property
def horse_power(self):
return self.description.horse_power if self.description else None
@property
def relais(self):
return self.description.relais if self.description else None
@property
def horodateur(self):
return self.description.horodateur if self.description else None
@property
def taximetre(self):
return self.description.taximetre if self.description else None
@property
def date_dernier_ct(self):
return self.description.date_dernier_ct if self.description else None
@property
def date_validite_ct(self):
return self.description.date_validite_ct if self.description else None
@property
def type_(self):
return self.description.type_ if self.description else None
def __repr__(self):
return '<Vehicle %r>' % unicode(self.id)
def __eq__(self, other):
return self.__repr__() == other.__repr__()
def __ne__(self, other):
return not self.__eq__(other)
@classmethod
def to_exclude(cls):
columns = list(
filter(lambda f: isinstance(getattr(HistoryMixin, f), Column),
HistoryMixin.__dict__.keys()))
columns += ["Vehicle", "vehicle_taxi", "descriptions"]
return columns
class Series(db.Model):
id = Column(db.Integer, primary_key=True)
name = Column(db.Unicode)
debut_year = Column(db.Integer, min=1936) # min = first broadcast date
class Article(self.Model):
__tablename__ = 'article'
__lazy_options__ = options
id = Column(sa.Integer, primary_key=True)
name = Column(sa.Unicode(255))
author_id = Column(sa.Integer, sa.ForeignKey(User.id))
from sqlalchemy_defaults import Column
from sqlalchemy_utils import ChoiceType
from sqlalchemy import func, CheckConstraint
from wtforms_alchemy import model_form_factory, ModelFieldList
from wtforms import FormField, HiddenField, TextField
import ujson as json
class ModelForm(model_form_factory(Form)):
pass
tags = db.Table(
'tags',
Column('tag_id', db.Integer, db.ForeignKey('tag.id')),
Column('post_id', db.Integer, db.ForeignKey('blog_post.id')),
)
class Tag(db.Model):
id = Column(
db.Integer,
primary_key=True,
)
name = Column(db.String(30), nullable=False, info={'label': 'Name'})
class TagForm(ModelForm):
class Meta(object):
class ADS(HistoryMixin, db.Model, AsDictMixin, FilterOr404Mixin):
@declared_attr
def added_by(cls):
return Column(db.Integer, db.ForeignKey('user.id'))
def __init__(self, licence_plate=None):
db.Model.__init__(self)
HistoryMixin.__init__(self)
if licence_plate:
self.vehicle = licence_plate
public_fields = set(['numero', 'insee'])
id = Column(db.Integer, primary_key=True)
numero = Column(db.String,
label=u'Numéro',
description=u'Numéro de l\'ADS')
doublage = Column(db.Boolean,
label=u'Doublage',
default=False,
nullable=True,
description=u'L\'ADS est elle doublée ?')
insee = Column(db.String,
label=u'Code INSEE de la commune d\'attribution',
description=u'Code INSEE de la commune d\'attribution')
vehicle_id = db.Column(db.Integer,
db.ForeignKey('vehicle.id'),
nullable=True)
_vehicle = db.relationship('Vehicle', lazy='joined')
owner_type = Column(Enum(*owner_type_enum, name='owner_type_enum'),
label=u'Type Propriétaire')
owner_name = Column(db.String, label=u'Nom du propriétaire')
category = Column(db.String, label=u'Catégorie de l\'ADS')
zupc_id = db.Column(db.Integer, db.ForeignKey('ZUPC.id'), nullable=True)
@property
def zupc(self):
return ZUPC.cache.get(self.zupc_id)
@validates('owner_type')
def validate_owner_type(self, key, value):
assert value in owner_type_enum
return value
@classmethod
def can_be_listed_by(cls, user):
return super(ADS,
cls).can_be_listed_by(user) or user.has_role('prefecture')
@classmethod
def marshall_obj(cls, show_all=False, filter_id=False, level=0, api=None):
if level >= 2:
return {}
return_ = super(ADS, cls).marshall_obj(show_all,
filter_id,
level=level + 1,
api=api)
return_['vehicle_id'] = fields.Integer()
return return_
@property
def vehicle(self):
return vehicle.Vehicle.query.get(self.vehicle_id)
@vehicle.setter
def vehicle(self, vehicle):
if isinstance(vehicle, string_types):
self.__vehicle = Vehicle(vehicle)
else:
self.__vehicle = Vehicle(vehicle.licence_plate)
def __repr__(self):
return '<ADS %r>' % unicode(self.id)
def __eq__(self, other):
return self.__repr__() == other.__repr__()
def __ne__(self, other):
return not self.__eq__(other)
class Actor(db.Model):
id = Column(db.Integer, primary_key=True)
name = Column(db.Unicode)
class DigitalState:
__lazy_options__ = {}
id = Column(Integer, primary_key=True)
running = Column(Boolean, nullable=False)
datetime = Column(DateTime, auto_now=True, nullable=False)
class User(CacheableMixin, db.Model, UserMixin, MarshalMixin, FilterOr404Mixin,
UserBase):
cache_label = 'users'
query_class = query_callable()
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
lazy='joined',
query_class=query_callable())
apikey = db.Column(db.String(36), nullable=False)
hail_endpoint_production = Column(db.String,
nullable=True,
label=u'Hail endpoint production',
description='Hail endpoint production')
hail_endpoint_staging = Column(db.String,
nullable=True,
label=u'Hail endpoint staging',
description='Hail endpoint staging')
hail_endpoint_testing = Column(db.String,
nullable=True,
label=u'Hail endpoint testing',
description='Hail endpoint testing')
commercial_name = Column(db.String,
nullable=True,
label='Nom commercial',
description='Votre nom commercial')
phone_number_customer = Column(
db.String,
nullable=True,
label=u'Numéro de téléphone du service client',
description=u'Numéro de téléphone de support pour les clients')
phone_number_technical = Column(
db.String,
nullable=True,
label=u'Numéro de téléphone du contact technique',
description=u'Numéro de téléphone du contact technique')
email_customer = Column(db.String,
nullable=True,
label=u'Email du service client',
description=u'Email de support pour les clients')
email_technical = Column(db.String,
nullable=True,
label=u'Email du contact technique',
description=u'Email du contact technique')
logos = db.relationship('Logo', backref="user", lazy='joined')
operator_header_name = Column(
db.String,
nullable=True,
label=u'Nom du header http pour l\'authentification',
description=u"""Cet header sera envoyé lors de la communication
de l'ODT vers votre serveur""")
operator_api_key = Column(
db.String,
nullable=True,
label=u'Valeur de la clé d\'api',
description=u"""Valeur de la clé d'api envoyé par l'ODT
à votre serveur pour l'authentification.""")
def __init__(self, *args, **kwargs):
kwargs['apikey'] = str(uuid.uuid4())
kwargs['password'] = encrypt_password(kwargs['password'])
kwargs['active'] = True
super(self.__class__, self).__init__(*args, **kwargs)
def added_by(cls):
return Column(db.Integer, db.ForeignKey('user.id'))
class Taxi(CacheableMixin, db.Model, HistoryMixin, AsDictMixin, GetOr404Mixin,
TaxiRedis):
@declared_attr
def added_by(cls):
return Column(db.Integer, db.ForeignKey('user.id'))
cache_label = 'taxis'
query_class = query_callable()
def __init__(self, *args, **kwargs):
db.Model.__init__(self)
HistoryMixin.__init__(self)
kwargs['id'] = kwargs.get('id', None)
if not kwargs['id']:
kwargs['id'] = str(get_short_uuid())
super(self.__class__, self).__init__(**kwargs)
HistoryMixin.__init__(self)
TaxiRedis.__init__(self, self.id)
id = Column(db.String, primary_key=True)
vehicle_id = db.Column(db.Integer,
db.ForeignKey('vehicle.id'),
nullable=True)
vehicle = db.relationship('Vehicle', backref='vehicle_taxi', lazy='joined')
ads_id = db.Column(db.Integer, db.ForeignKey('ADS.id'), nullable=True)
ads = db.relationship('ADS', backref='ads', lazy='joined')
driver_id = db.Column(db.Integer,
db.ForeignKey('driver.id'),
nullable=True)
driver = db.relationship('Driver', backref='driver', lazy='joined')
_ACTIVITY_TIMEOUT = 15 * 60 #Used for dash
@property
def rating(self):
return 4.5
@property
def status(self):
return self.vehicle.description.status
@status.setter
def status(self, status):
self.vehicle.description.status = status
self.last_update_at = datetime.now()
def is_free(self, min_time=None):
return self._is_free(self.vehicle.descriptions,
lambda desc: User.query.get(desc.added_by).email,
lambda desc: desc.status, min_time)
def set_free(self):
#For debugging purposes
for desc in self.vehicle.descriptions:
desc.status = 'free'
@property
def driver_professional_licence(self):
return self.driver.professional_licence
@property
def vehicle_licence_plate(self):
return self.vehicle.licence_plate
@property
def ads_numero(self):
return self.ads.numero
@property
def driver_insee(self):
return self.ads.insee
@property
def driver_departement(self):
return self.driver.departement
map_hail_status_taxi_status = {
'emitted': 'free',
'received': 'answering',
'sent_to_operator': 'answering',
'received_by_operator': 'answering',
'received_by_taxi': 'answering',
'accepted_by_taxi': 'answering',
'accepted_by_customer': 'oncoming',
'declined_by_taxi': 'free',
'declined_by_customer': 'free',
'incident_customer': 'free',
'incident_taxi': 'free',
'timeout_customer': 'free',
'timeout_taxi': 'free',
'outdated_customer': 'free',
'outdated_taxi': 'free',
'failure': 'free'
}
def synchronize_status_with_hail(self, hail):
description = self.vehicle.get_description(hail.operateur)
description.status = self.map_hail_status_taxi_status[hail.status]
self.last_update_at = datetime.now()
RawTaxi.flush(self.id)
from flask.ext.security import RoleMixin, UserMixin
from sqlalchemy_defaults import Column
from .core import db
roles_users = db.Table(
'roles_users',
Column('user_id', db.Integer, db.ForeignKey('user.id')),
Column('role_id', db.Integer, db.ForeignKey('role.id')),
)
class Role(db.Model, RoleMixin):
"""Flask-Security Role model."""
id = Column(db.Integer, primary_key=True)
created = Column(db.DateTime, auto_now=True)
name = Column(db.Unicode, unique=True)
description = Column(db.UnicodeText)
class User(db.Model, UserMixin):
"""Flask-Security User model."""
id = Column(db.Integer, primary_key=True)
created = Column(db.DateTime, auto_now=True)
email = Column(db.Unicode)
password = Column(db.String(255))
active = Column(db.Boolean, default=True, nullable=False)
confirmed_at = Column(db.DateTime)
roles = db.relationship(
'Role',
secondary=roles_users,
class Role(db.Model, RoleMixin):
"""Flask-Security Role model."""
id = Column(db.Integer, primary_key=True)
created = Column(db.DateTime, auto_now=True)
name = Column(db.Unicode, unique=True)
description = Column(db.UnicodeText)
