class ReservationReq(db.Model):
id = db.Column(db.Integer, primary_key=True)
requestor_id = db.Column(db.Integer, db.ForeignKey("user.id"))
owner_id = db.Column(db.Integer, db.ForeignKey("user.id"))
status_pending = db.Column(db.Boolean(), default=True)
status_accepted = db.Column(db.Boolean(), default=False)
seat_id = db.Column(db.Integer, db.ForeignKey("seat.id"))
requestor = db.relationship("User", foreign_keys=[requestor_id])
owner = db.relationship("User", foreign_keys=[owner_id])
seat = db.relationship("Seat", foreign_keys=[seat_id])
class Hobby(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False,
server_default="")
name = db.Column(db.String(32), index=True, nullable=False)
sunday = db.Column(db.Boolean, default=False)
monday = db.Column(db.Boolean, default=False)
tuesday = db.Column(db.Boolean, default=False)
wednesday = db.Column(db.Boolean, default=False)
thursday = db.Column(db.Boolean, default=False)
friday = db.Column(db.Boolean, default=False)
saturday = db.Column(db.Boolean, default=False)
color = db.Column(db.String(3), default="Red")
#Need to check for null when displaying
duration = db.Column(db.String(2), nullable=False)
notes = db.Column(db.Text)
goals = db.Column(db.Text)
dates = db.relationship('Day',
secondary=days,
backref='hobbies',
lazy=True)
def __repr__(self):
return '<Hobby {}, Notes {}>'.format(self.name, self.notes)
class Device(db.Model, SerialiseMixin):
__tablename__ = 'device'
id = Column(Integer, primary_key=True)
created_at = Column(DateTime, index=True, nullable=False)
device_type = Column(Integer, index=True)
device_sub_type = Column(Integer, index=True)
device_id = Column(String(20), nullable=False, unique=True)
area_id = Column(Integer, ForeignKey('area.id'))
area = db.relationship(
"Area", backref=db.backref('devices'), lazy='joined', uselist=False)
def __init__(self, device_type, device_sub_type, device_id, area=None):
super().__init__()
self.created_at = datetime.utcnow()
self.device_type = device_type
self.device_sub_type = device_sub_type
self.device_id = device_id
self.area = area
@classmethod
def get_or_create(cls, device_type, device_sub_type, device_id):
return get_or_create(cls, device_type=device_type,
device_sub_type=device_sub_type,
device_id=device_id)
def __repr__(self):
return "Device(name=%s, ID=%r)" % (
self.area, self.device_id)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
owned_car = db.relationship("Car", backref="car_owner", lazy="dynamic")
owned_camp = db.relationship("Camp", backref="camp_owner", lazy="dynamic")
assigned_seat = db.Column(db.Integer, db.ForeignKey("seat.id"))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return "<Username: {}>".format(self.username)
class Seat(db.Model):
id = db.Column(db.Integer, primary_key=True)
available = db.Column(db.Boolean(), default=True)
reserved = db.Column(db.Boolean(), default=False)
taken = db.Column(db.Boolean(), default=False)
related_car = db.Column(db.Integer, db.ForeignKey("car.id"))
related_user = db.relationship("User", backref="user_id", lazy="dynamic")
def __repr__(self):
return "<Seat=> Related Car {} >".format(self.related_car)
class Day(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Integer)
month = db.Column(db.Integer)
year = db.Column(db.Integer)
#Has this date already past
past = db.Column(db.Boolean)
#Is date in current month
curr = db.Column(db.Boolean)
_hobbies = db.relationship('Hobby', secondary=days)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image_file}')"
class Car(db.Model):
id = db.Column(db.Integer, primary_key=True)
number_of_seats = db.Column(db.Integer)
starting_location = db.Column(db.String(140))
owner_id = db.Column(db.Integer, db.ForeignKey("user.id"))
seats = db.relationship("Seat", backref="seat_id", lazy="dynamic")
linked_camp = db.Column(db.Integer, db.ForeignKey("camp.id"))
def __repr__(self):
return "<Car=> Owner:{} ".format(
self.owner_id, self.number_of_seats) + "Seats:{} ".format(
self.number_of_seats)
class Camp(db.Model):
id = db.Column(db.Integer, primary_key=True)
owner_id = db.Column(db.Integer, db.ForeignKey("user.id"))
name = db.Column(db.String(128), index=True)
group = db.Column(db.String(64), index=True)
location = db.Column(db.String(128), index=True)
start_date = db.Column(db.DateTime, index=True, nullable=True)
end_date = db.Column(db.DateTime, index=True, nullable=True)
key = db.Column(db.String(8), index=True, unique=True)
linked_car = db.relationship("Car", backref="car_id", lazy="dynamic")
def __repr__(self):
return "<CampName{} ".format(self.name) + " group:{} ".format(
self.group) + " key:{}>".format(self.key)
class DeviceSeries(db.Model, SerialiseMixin):
__tablename__ = 'device_series'
id = Column(Integer, primary_key=True)
created_at = Column(DateTime, nullable=False, index=True)
series_id = Column(Integer, ForeignKey('series.id'), nullable=False)
device_id = Column(Integer, ForeignKey('device.id'), nullable=False)
device = db.relationship(
"Device", backref=db.backref('device_series'), lazy='joined')
series = db.relationship(
"Series", backref=db.backref('device_series'), lazy='joined')
__table_args__ = (
UniqueConstraint('series_id', 'device_id', name='_series_device_uc'),
)
def __init__(self, device, series):
super().__init__()
self.created_at = datetime.utcnow()
self.series = series
self.device = device
@property
def latest_reading(self):
return DataPoint.query\
.filter_by(device_series=self)\
.order_by(DataPoint.created_at.desc())\
.limit(1).first()
@classmethod
def get_or_create(cls, **kwargs):
return get_or_create(cls, **kwargs)
def __repr__(self):
return "DeviceSeries(device_id=%s, series_id=%s)" % (
self.device_id, self.series_id)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32),
index=True,
unique=True,
nullable=False)
email = db.Column(db.String(128), index=True, unique=True, nullable=False)
password_hash = db.Column(db.String(128))
hobbies = db.relationship('Hobby', backref='user', lazy=True)
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def get_password(self, password):
return check_password_hash(self.password_hash, password)
class DataPoint(db.Model, SerialiseMixin):
__tablename__ = 'data_point'
id = Column(Integer, primary_key=True)
created_at = Column(DateTime, nullable=False, index=True)
value = Column(Numeric, nullable=False, index=True)
device_series_id = Column(Integer, ForeignKey('device_series.id'),
index=True, nullable=False)
device_series = db.relationship(
"DeviceSeries", order_by=created_at.desc(),
backref=db.backref('data_points'))
def __init__(self, device_series, value, created_at=None):
self.created_at = datetime.utcnow()
super().__init__()
self.device_series = device_series
self.value = value
self.created_at = created_at
def push_to_redis(self):
ds = self.device_series
key = "D-%s:S-%s" % (ds.device_id, ds.series_id)
redis_series.push(key, self.value, self.created_at)
@classmethod
def record(cls, series, device, value, created_at=None):
ds = DeviceSeries.get_or_create(device=device, series=series)
data_point = DataPoint(device_series=ds, value=value)
if created_at is None:
data_point.created_at = datetime.utcnow()
data_point.push_to_redis()
db.session.add(data_point)
return data_point
def __repr__(self):
return "<Data Point(%s, value=%s, created_at=%s)>" % (
self.device_series, self.value, self.created_at)
class Series(db.Model, SerialiseMixin):
__tablename__ = 'series'
id = Column(Integer, primary_key=True)
created_at = Column(DateTime, index=True, nullable=False)
name = Column(String(20), nullable=False, index=True, unique=True)
graph_id = Column(Integer, ForeignKey('graph.id'))
graph = db.relationship(
"Graph", backref=db.backref('series'), lazy='joined', uselist=False)
def __init__(self, name):
super().__init__()
self.created_at = datetime.utcnow()
self.name = name
@classmethod
def get_or_create(cls, **kwargs):
r = get_or_create(cls, **kwargs)
return r
def __repr__(self):
return "Series(name=%r)" % (self.name)