class RoomType(BaseDataModel):
__tablename__ = 'roomtype'
description = db.Column(db.String(128))
bedcount = db.Column(db.Integer())
# bedtype
# roomstate
currency = db.Column(db.Integer(),
db.ForeignKey('currency.id', ondelete='NO ACTION'),
default=1)
price = db.Column(db.Float(), nullable=False)
pricechd = db.Column(db.Float(), nullable=False)
class Capteur(db.Model):
captId = db.Column(db.Integer, primary_key=True)
cName = db.Column(db.String(100))
cTel = db.Column(db.String(20))
cType = db.Column(db.String(100))
frequence = db.Column(db.Float(5, 2))
formule = db.Column(db.String(255))
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), index=True)
owner = db.relationship('User',
backref=db.backref('capteurs', lazy='dynamic'))
# méthode d'affichage
def __repr__(self):
return "<Capteur (%d) %s>" % (self.captId, self.cName)
@property
def position(self):
return self.positions.first()
def serialize(self):
return {
'captId': self.captId,
'cName': self.cName,
'cTel': self.cTel,
'cType': self.cType,
'frequence': self.frequence,
'formule': self.frequence,
'pos_x': self.position.position_x,
'pos_y': self.position.position_y,
}
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
price = db.Column(db.Float(precision=2), nullable=False)
store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
# different value for the lazy argument
# https://medium.com/@ns2586/sqlalchemys-relationship-and-lazy-parameter-4a553257d9ef
store = db.relationship('StoreModel', backref='items', lazy=True)
def __init__(self, name, price, store_id):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {'name': self.name, 'price': self.price}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
""""insert or update ItemModel to db."""
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Sentence(db.Model):
__tablename__ = 'sentence'
id = db.Column(db.Integer(), primary_key=True)
text = db.Column(db.String())
sentiment = db.Column(db.Float())
status = db.Column(db.String()) #CONTEXT, SENTIMENT, PRED, DONE
date = db.Column(db.String())
time = db.Column(db.String())
article_id = db.Column(db.Integer(), db.ForeignKey('article.id'))
context = db.Column(db.String(), db.ForeignKey("company.stock_code"))
def __init__(self, text, article_id, date, time):
#self.id = id
self.text = text
self.article_id = article_id
self.status = "CONTEXT"
self.date = self.time = datetime.strptime(date, '%m/%d/%Y')
self.time = datetime.strptime(time, '%H:%M:%S')
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'text': self.text,
'sentiment': self.sentiment,
'status': self.status,
'article_id': self.article_id,
'date': self.date.strftime("%m/%d/%Y"),
'time': self.time.strftime("%H:%M:%S"),
'context': self.context
}
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False, unique=True)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(200), nullable=False)
items = db.relationship("Item", backref="user")
rating = db.Column(db.Float())
profile_picture = db.Column(db.String(300), default=None)
is_admin = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(), nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(), nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
#Funktio joka hakee käyttäjänimen mukaan
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
#Funktio joka hakee sähköpostin mukaan
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
# Funktio joka hakee käyttäjän id.n mukaan
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def save(self):
db.session.add(self)
db.session.commit()
class Sale(BaseDataModel):
__tablename__ = 'sale'
description = db.Column(db.String(128))
price = db.Column(db.Float(), nullable=False)
currency = db.Column(db.Integer(),
db.ForeignKey('currency.id', ondelete='NO ACTION'),
default=1)
reservationid = db.Column(
db.Integer(), db.ForeignKey('reservation.id', ondelete='NO ACTION'))
class ProductSku(BaseModelMixin, db.Model):
sku_code = db.Column(db.String(16), nullable=False)
description = db.Column(db.String(500), nullable=False)
product_id = db.Column(db.Integer(), db.ForeignKey('product.id'))
price = db.Column(db.Float(), nullable=False, default=0)
# product_name = db.Column(db.String(), db.ForeignKey('product.name'))
# prices = db.relationship('ProductPrice', backref='sku',
# lazy='subquery', )
cost = db.Column(db.Float())
msrp = db.Column(db.Float())
def __init__(self, sku_code, description):
self.sku_code = sku_code
self.description = description
def __repr__(self):
return "<SKU '{}'>".format(self.sku_code)
@property
def formated_price(self):
return "${0:.2f}".format(self.price)
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(1000), nullable=False)
price = db.Column(db.Float(3), nullable=False)
stock = db.Column(db.Integer, nullable=False)
image_path = db.Column(db.String(1000))
def __init__(self, name: str, description: str, price: float, stock: int,
image_path: str):
self.name = name
self.description = description
self.price = price
self.stock = stock
self.image_path = image_path
def __repr__(self):
return "<Product %r>" % self.name
class Eye_Data(db.Model):
__tablename__ = 'eye_data_entries'
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.String(80))
score = db.Column(db.Float())
def __init__(self, timestamp, score):
self.timestamp = timestamp
self.score = score
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'timestamp': self.timestamp,
'score': self.score
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
# personal information columns
username = db.Column(db.String(80), nullable=False, unique=True)
password = db.Column(db.String(1000), nullable=False)
email = db.Column(db.String(1000), nullable=False)
# cart columns
n_items = db.Column(db.Integer, nullable=False)
subtotal = db.Column(db.Float(3), nullable=False)
def __init__(self, username: str, password: str, email: str):
self.username = username
self.password = password
self.email = email
self.n_items = 0
self.subtotal = 0
def __repr__(self):
return "<User %r>" % self.username
class Product(db.Model):
id = db.Column(db.Integer(), primary_key=True)
type = db.Column(db.String(10))
origin = db.Column(db.String(4))
destination = db.Column(db.String(4))
adults = db.Column(db.Integer())
childs = db.Column(db.Integer())
infants = db.Column(db.Integer())
flights = db.relationship('Flight')
total_duration = db.Column(db.Integer())
prices = db.Column(CastingArray(JSON))
total_price = db.Column(db.Float())
price_currency = db.Column(db.String(3))
airlines = db.Column(ARRAY(db.String(2)))
departure_date = db.Column(db.Date())
return_date = db.Column(db.Date())
flight_classes = db.Column(ARRAY(db.String(1)))
search_id = db.Column(db.Integer(), db.ForeignKey('search.id'))
def __repr__(self):
return '{origin} - {destination}'.format(origin=self.origin,
destination=self.destination)
class Zip(db.Model):
__tablename__ = 'zips'
id = db.Column(db.String(64), primary_key=True)
zip = db.Column(db.String(6), nullable=False, index=True)
state = db.Column(db.String(2), nullable=False)
district = db.Column(db.String(2), nullable=False)
factor = db.Column(db.Float(8), nullable=False)
def __init__(self,
zip=None,
state=None,
district=None,
factor=None,
**kwargs):
self.id = str(uuid.uuid4())
self.zip = zip
self.state = state
self.district = district
self.factor = factor
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
price = db.Column(db.Float(precision=2), nullable=False)
store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
store = db.relationship('StoreModel')
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Employee(BaseDataModel):
__tablename__ = 'employee'
address = db.Column(db.String(256))
bankname = db.Column(db.String(64))
birthdate = db.Column(db.Date())
birthplace = db.Column(db.String(64))
bloodgrp = db.Column(db.String(3))
city = db.Column(db.String(64))
country = db.Column(db.String(64))
fullname = db.Column(db.String(64))
email = db.Column(db.String(64), unique=True)
gender = db.Column(db.String(6))
iban = db.Column(db.String(26))
idno = db.Column(db.String(64))
maritalstatus = db.Column(db.Boolean())
paycurrid = db.Column(db.Integer(),
db.ForeignKey('currency.id', ondelete='NO ACTION'),
default=1)
salaryamount = db.Column(db.Float(), nullable=False, default=0.0)
salaryday = db.Column(db.Integer, nullable=False, default=1)
enddate = db.Column(db.Date())
tel = db.Column(db.String(16))
userid = db.Column(db.Integer, db.ForeignKey('user.id',
ondelete='SET NULL'))
class Person(db.Model):
uuid = db.Column(UUID(as_uuid=True),
unique=True,
nullable=False,
primary_key=True,
default=generate_uuid)
survived = db.Column(db.Boolean, default=False)
passenger_class = db.Column(db.Integer, nullable=False)
name = db.Column(db.String(100), nullable=False)
sex = db.Column(db.Enum(SexEnum), nullable=False, default=SexEnum.other)
age = db.Column(db.Integer, nullable=False)
siblings_or_spouses_aboard = db.Column(db.Integer, nullable=False)
parents_or_children_aboard = db.Column(db.Integer, nullable=False)
fare = db.Column(db.Float(), nullable=False)
__tablename__ = 'person'
def __repr__(self):
return f'<Person {self.name}>'
def __str__(self):
return self.name
def __init__(self, **kwargs):
self.uuid = kwargs.pop('uuid', None)
self.survived = kwargs.pop('survived', None)
self.passenger_class = kwargs.pop('passenger_class', None)
self.name = kwargs.pop('name', None)
self.sex = kwargs.pop('sex', None)
self.age = kwargs.pop('age', None)
self.siblings_or_spouses_aboard = kwargs.pop(
'siblings_or_spouses_aboard', None)
self.parents_or_children_aboard = kwargs.pop(
'parents_or_children_aboard', None)
self.fare = kwargs.pop('fare', None)
@validates('passenger_class')
def validate_passenger_class(self, key, value):
if value is None:
raise AssertionError('No `passengerClass` provided')
if not isinstance(value, int):
raise AssertionError(
'Incorrect type of value for `passengerClass`')
return value
@validates('name')
def validate_name(self, key, value):
if value is None:
raise AssertionError('No `name` provided')
if not isinstance(value, str):
raise AssertionError('Incorrect type of value for `name`')
if len(value) > 100:
raise AssertionError('To long value for `name`. Max 100 chars.')
return value
@validates('sex')
def validate_sex(self, key, value):
if value is None:
raise AssertionError('No `sex` provided')
if not value in [item.value for item in SexEnum]:
raise AssertionError('Incorrect value for `sex`')
return value
@validates('age')
def validate_age(self, key, value):
if value is None:
raise AssertionError('No `age` provided')
if not isinstance(value, int):
raise AssertionError('Incorrect type of value for `age`')
return value
@validates('siblings_or_spouses_aboard')
def validate_siblings_or_spouses_aboard(self, key, value):
if value is None:
raise AssertionError('No `siblingsOrSpousesAboard` provided')
if not isinstance(value, int):
raise AssertionError(
'Incorrect type of value for `siblingsOrSpousesAboard`')
return value
@validates('parents_or_children_aboard')
def validate_parents_or_children_aboard(self, key, value):
if value is None:
raise AssertionError('No `parentsOrChildrenAboard` provided')
if not isinstance(value, int):
raise AssertionError(
'Incorrect type of value for `parentsOrChildrenAboard`')
return value
@validates('fare')
def validate_fare(self, key, value):
if value is None:
raise AssertionError('No `fare` provided')
if not isinstance(value, float):
raise AssertionError('Incorrect type of value for `fare`')
return value
def update(self, **kwargs):
for k, v in kwargs.items():
if hasattr(self, self.to_snake_case(k)):
setattr(self, self.to_snake_case(k), v)
def save(self):
db.session.add(self)
db.session.commit()
self.refresh()
def delete(self):
db.session.delete(self)
db.session.commit()
def refresh(self):
db.session.refresh(self)
@staticmethod
def get_all():
return Person.query.all()
@staticmethod
def to_camel_case(snake_str):
return snake_str[0].lower() + string.capwords(
snake_str, sep='_').replace('_',
'')[1:] if snake_str else snake_str
@staticmethod
def to_snake_case(camel_str):
return SNAKE_CASE.sub(r'_\1', camel_str).lower()
def dump(self):
return json.loads(
json.dumps(dict([(self.to_camel_case(k), v)
for k, v in vars(self).items()
if not k.startswith('_')]),
cls=PersonEncoder))
@classmethod
def load(cls, **kwargs):
return cls(**dict([(cls.to_snake_case(k), v)
for k, v in kwargs.items()]))
class ProductSkuPrice(BaseModelMixin, db.Model):
product_id = db.Column(db.Integer(), db.ForeignKey('product.id'))
price = db.Column(db.Float(), nullable=False)
def __repr__(self):
print "<ProductPrice '{}'>".format(self.product_id)
