class Like(db.Model):
"""
Describes a like given by some user to some post
"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
post_id = db.Column(db.Integer, db.ForeignKey("post.id"))
date = db.Column(db.Date, default=datetime.date.today())
time = db.Column(db.Time, default=datetime.datetime.now().time())
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def __repr__(self):
return f"<Like: id={self.id}, user_id={self.user_id}, post_id={self.post_id}, " \
f"date={str(self.date)}, time={str(self.time)}>"
def json(self):
return {
"user_id": self.user_id,
"post_id": self.post_id,
"date": str(self.date),
"time": str(self.time)
}
class FavourOfferModel(BaseModel):
__tablename__='favour_offers'
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('orders.order_id', ondelete='CASCADE'), nullable=False)
# usuario que entrega el pedido
user_id = db.Column(db.Integer, db.ForeignKey('normal_users.user_id', ondelete='CASCADE'), nullable=False)
points = db.Column(db.Integer,nullable = False)
created_at = db.Column(db.DateTime)
created_at_seconds = db.Column(db.Integer)
state = db.Column(db.String(128), nullable=False)
# class constructor
def __init__(self, data):
"""
Class constructor
"""
self.order_id = data.get("order_id")
self.user_id = data.get('user_id')
self.points = data.get('points')
self.created_at = datetime.datetime.utcnow()
self.created_at_seconds = int(round(time.time()))
self.state = data.get('state')
@staticmethod
def get_offer(offer_id):
response = FavourOfferModel.query.get(offer_id)
if not response:
raise NotFoundException("Invalid ID")
return response
class Build(db.Model):
_id = db.Column(db.Integer, primary_key=True) # ID in database (is unique)
id = db.Column(
db.Integer) # ID in job, together with job_id is an unique tuple
description = db.Column(db.Text)
commands = db.Column(db.Text)
output = db.Column(db.Text)
status = db.Column(db.String(32))
job_id = db.Column(db.Integer, db.ForeignKey("job.id"))
node_id = db.Column(db.Integer, db.ForeignKey("node.id"))
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def to_dict(self):
return {
'id': self.id,
'description': self.description,
'commands': self.commands,
'output': self.output,
'status': self.status,
'job_id': self.job_id,
'node_id': self.node_id,
'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S")
}
def __repr__(self):
return f"<id {self.id}, description : {self.description}>"
class OrderOffersModel(BaseModel):
# table name
__tablename__ = 'order_oferts'
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('orders.order_id', ondelete='CASCADE'), nullable=False)
delivery_id = db.Column(db.Integer, db.ForeignKey('delivery_users.user_id', ondelete='CASCADE'), nullable=False)
delivery_price = db.Column(db.Float,nullable=False)
delivery_pay = db.Column(db.Float,nullable = False)
created_at = db.Column(db.DateTime)
created_at_seconds = db.Column(db.Integer)
state = db.Column(db.String(128), nullable=False)
# class constructor
def __init__(self, data):
"""
Class constructor
"""
self.order_id = data.get("order_id")
self.delivery_id = data.get('delivery_id')
self.delivery_price = data.get('delivery_price')
self.delivery_pay = data.get('delivery_pay')
self.created_at = datetime.datetime.utcnow()
self.created_at_seconds = int(round(time.time()))
self.state = data.get('state')
@staticmethod
def get_offer(offer_id):
response = OrderOffersModel.query.get(offer_id)
if not response:
raise NotFoundException("Invalid ID")
return response
class ActivityLog(db.Model):
"""
Describes an activity by (optional) user (and/or) on some (optional) post,
or just a message about what was done
"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=True)
post_id = db.Column(db.Integer, db.ForeignKey("post.id"), nullable=True)
action = db.Column(db.String(255))
date = db.Column(db.Date, default=datetime.date.today())
time = db.Column(db.Time, default=datetime.datetime.now().time())
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def __repr__(self):
return f"<Activity: id={self.id}, user={self.user_id}, post={self.post_id}, " \
f"action={self.action}, date={self.date}, time={self.time}>"
def json(self):
return {
"user_id": self.user_id,
"post_id": self.post_id,
"action": self.action,
"date": str(self.date),
"time": str(self.time)
}
class EventModel(db.Model):
__tablename__ = 'events'
id = db.Column(db.Integer, primary_key=True)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
owner = db.relationship('UserModel', foreign_keys=[owner_id])
community_id = db.Column(db.Integer,
db.ForeignKey('communities.id'),
nullable=False)
community = db.relationship('CommunityModel', foreign_keys=[community_id])
title = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text, nullable=True)
start = db.Column(db.DateTime())
end = db.Column(db.DateTime())
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'owner': fields.Nested(UserModel.get_marshaller()),
'title': fields.String,
'description': fields.String,
'start': fields.DateTime,
'end': fields.DateTime,
}
@classmethod
def delete_by_id(cls, event_id):
event = db.session.query(cls).filter(cls.id == event_id).first()
if event:
db.session.delete(event)
db.session.commit()
else:
raise NoData
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_by_community(cls, community_id, from_datetime, to_datetime):
return cls.query.filter_by(community_id=community_id). \
filter(EventModel.end >= from_datetime, EventModel.start <= to_datetime).all()
@classmethod
def find_next_n_by_community(cls, community_id, n):
return cls.query.filter_by(community_id=community_id). \
filter(EventModel.end >= datetime.datetime.utcnow()).order_by(EventModel.start.asc()).limit(n).all()
class Follow(db.Model):
__tablename__ = "follows"
follower_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
primary_key=True)
followed_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
def __repr__(self):
return f"<User ID {self.follower_id} follows {self.followed_id} as of {self.timestamp}>"
class StudyClass(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(10), unique=True, nullable=False)
year_of_study = db.Column(db.String(2), unique=False, nullable=False)
schedule_id = db.Column(db.Integer, db.ForeignKey('schedule.id'))
professor_id = db.Column(db.Integer, db.ForeignKey('professor.id'))
schedule = db.relationship('Schedule',
backref=db.backref('classes', lazy=True))
discipline = db.relationship('Discipline', backref='study_class')
def __repr__(self):
return f'{self.name} {self.year_of_study}'
class Discipline(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=False, nullable=False)
# Day of the week + hour interval of the class
course_schedule = db.Column(db.String(50), unique=False, nullable=True)
lab_schedule = db.Column(db.String(50), unique=False, nullable=True)
seminary_schedule = db.Column(db.String(50), unique=False, nullable=True)
schedule_id = db.Column(db.Integer, db.ForeignKey('schedule.id'))
study_class_id = db.Column(db.Integer, db.ForeignKey('study_class.id'))
professor_id = db.Column(db.Integer, db.ForeignKey('professor.id'))
def __repr__(self):
return f'{self.name} {self.course_schedule} {self.lab_schedule} {self.seminary_schedule}'
class AccountSettingsModel(db.Model):
__tablename__ = 'account_settings'
id = db.Column(db.Integer, primary_key=True)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
auto_load_parking_place_gps_location = db.Column(db.Boolean, default=False)
parking_place_required = db.Column(db.Boolean, default=False)
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'auto_load_parking_place_gps_location': fields.Boolean,
'parking_place_required': fields.Boolean
}
@classmethod
def find_by_user_id(cls, user_id):
return cls.query.filter_by(user_id=user_id).first()
class Post(db.Model):
__tablename__ = "posts"
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
body_html = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
author_id = db.Column(db.Integer, db.ForeignKey("users.id"))
@staticmethod
def on_changed_body(target, value, oldvalue, initiator):
allowed_tags = [
"a",
"abbr",
"acronym",
"b",
"blockquote",
"code",
"em",
"i",
"li",
"ol",
"pre",
"strong",
"ul",
"h1",
"h2",
"h3",
"p",
]
target.body_html = bleach.linkify(
bleach.clean(markdown(value, output_format="html"),
tags=allowed_tags,
strip=True))
class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
deleted = db.Column(db.Boolean, default=False)
deleted_at = db.Column(db.DateTime, default=None)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
title = db.Column(db.String(200), nullable=False)
thumbnail = db.Column(db.Text)
slug = db.Column(db.String(200), nullable=False, unique=True)
brief = db.Column(db.Text, nullable=False)
content = db.Column(db.Text, nullable=False)
last_edited_at = db.Column(db.DateTime)
user = db.relationship('Users', backref=db.backref('posts', lazy=True))
votes = db.relationship("Votes", back_populates="post")
tags = db.relationship('Tags',
secondary=post_tags,
lazy='subquery',
backref=db.backref('posts', lazy=True))
def __repr__(self):
return '<Posts %r>' % self.title
class Character(db.Model):
__tablename__ = 'character'
id = db.Column(db.Integer, primary_key=True)
available = db.Column(db.Integer)
collectionURI = db.Column(db.String(140))
returned = db.Column(db.Integer)
comic_id = db.Column(db.Integer, db.ForeignKey('comics.id'))
class NormalUserModel(UserModel):
# table name
__tablename__ = 'normal_users'
user_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
primary_key=True)
suscripcion = db.Column(db.String(128), nullable=False)
picture = db.Column(db.String(256), nullable=True)
make_favours = db.Column(db.Boolean, nullable=False)
__mapper_args__ = {
'polymorphic_identity': 'normal_users',
}
# class constructor
def __init__(self, data):
"""
Class constructor
"""
super(NormalUserModel, self).__init__(data)
self.suscripcion = data.get('suscripcion')
self.picture = data.get('picture')
self.make_favours = data.get('make_favours', True)
@staticmethod
def get_user(user_id):
response = NormalUserModel.query.get(user_id)
if not response:
raise NotFoundException("Invalid ID")
return response
class ProductModel(BaseModel):
# table name
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
shop_id = db.Column(db.Integer, db.ForeignKey('shops.id', ondelete='CASCADE'), nullable=False)
name = db.Column(db.String(128), nullable=False)
description = db.Column(db.String(128), nullable=False)
price = db.Column(db.Float, nullable=False)
# class constructor
def __init__(self, data):
"""
Class constructor
"""
self.shop_id = data.get('shop_id')
self.name = data.get('name')
self.description = data.get('description')
self.price = data.get('price')
@staticmethod
def get_product(product_id):
response = ProductModel.query.get(product_id)
if not response:
raise NotFoundException("Invalid ID")
return response
class Comments(db.Model):
id = db.Column(db.Integer, primary_key=True)
deleted = db.Column(db.Boolean, default=False)
deleted_at = db.Column(db.DateTime, default=None)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
content = db.Column(db.Text, nullable=False)
post = db.relationship('Posts', backref=db.backref('comments', lazy=True))
user = db.relationship('Users', backref=db.backref('comments', lazy=True))
def __repr__(self):
return '<Comment %r>' % self.content
class OrderProductsModel(BaseModel):
# table name
__tablename__ = 'order_products'
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('orders.order_id', ondelete='CASCADE'), nullable=False)
product_id = db.Column(db.Integer, db.ForeignKey('products.id', ondelete='CASCADE'), nullable=False)
units = db.Column(db.Integer, nullable=False)
# class constructor
def __init__(self, data):
"""
Class constructor
"""
self.product_id = data.get('product_id')
self.units = data.get('units')
class Name(db.Model):
__tablename__ = 'name'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(400))
disposition = db.Column(db.String(400))
hat_id = db.Column(db.Integer, db.ForeignKey('hat.id'))
class Votes(db.Model):
id = db.Column(db.Integer, primary_key=True)
deleted = db.Column(db.Boolean, default=False)
deleted_at = db.Column(db.DateTime, default=None)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
vote = db.Column(db.Boolean, default=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
post = db.relationship("Posts", uselist=False, back_populates="votes")
user = db.relationship('Users', backref=db.backref('votes', lazy=True))
def __repr__(self):
return '<Vote %r>' % self.vote
class TourPassengerLinkModel(db.Model):
__tablename__ = 'tour_passenger_link'
tour_id = db.Column(db.Integer,
db.ForeignKey('tours.id'),
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
tour = db.relationship('TourModel')
user = db.relationship('UserModel')
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
def persist(self):
db.session.add(self)
db.session.commit()
class OrderModel(BaseModel):
# table name
__tablename__ = 'orders'
order_id = db.Column(db.Integer, primary_key=True)
shop_id = db.Column(db.Integer, nullable=False)
products = db.relationship('OrderProductsModel', backref='order', lazy=True)
latitud = db.Column(db.Float, nullable=False)
longitud = db.Column(db.Float, nullable=False)
payWithPoints = db.Column(db.Boolean, nullable=False)
favourPoints = db.Column(db.Integer, nullable=False)
state = db.Column(db.String(128), nullable=False)
price = db.Column(db.Float,nullable = False)
delivery_price = db.Column(db.Float)
delivery_pay = db.Column(db.Float)
user_id = db.Column(db.Integer, db.ForeignKey('normal_users.user_id'), nullable=False)
delivery_id = db.Column(db.Integer, db.ForeignKey('users.user_id'), nullable=True)
created_at = db.Column(db.DateTime)
modified_at = db.Column(db.DateTime)
delivery_review = db.Column(db.Float, nullable = True)
shop_review = db.Column(db.Float, nullable = True)
discount = db.Column(db.Boolean, nullable=False)
# class constructor
def __init__(self, data):
"""
Class constructor
"""
self.shop_id = data.get('shop_id')
self.latitud = data.get('latitude')
self.longitud = data.get('longitude')
self.payWithPoints = data.get('payWithPoints')
self.favourPoints = data.get('favourPoints', 0)
self.state = data.get('state')
self.user_id = data.get('user_id')
self.delivery_id = data.get('delivery_id', None)
self.price = data.get("price")
self.created_at = datetime.datetime.utcnow()
self.modified_at = datetime.datetime.utcnow()
self.delivery_review = None
self.shop_review = None
self.discount = data.get("discount", False)
class ProductModel(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
price = db.Column(db.Integer, nullable=False)
description = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
images = db.relationship('ProductImagesModel',
backref='product',
lazy=True,
cascade="all,delete")
class CarModel(db.Model):
__tablename__ = 'cars'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
make = db.Column(db.String(120), nullable=False)
model = db.Column(db.String(120), nullable=False)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
owner = db.relationship('UserModel', back_populates='cars')
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'name': fields.String,
'make': fields.String,
'model': fields.String,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'owner': fields.Nested(UserModel.get_marshaller())
}
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def return_all(cls):
return CarModel.query.all()
@classmethod
def return_all_for_user(cls, user_id):
return CarModel.query.filter(cls.owner_id == user_id).all()
@classmethod
def delete_all(cls):
db.session.query(cls).delete()
db.session.commit()
@classmethod
def delete_by_id(cls, id):
car = db.session.query(cls).filter(cls.id == id).first()
if car:
db.session.delete(car)
db.session.commit()
else:
raise NoData
class CronBuild(db.Model):
cron_key = db.Column(db.String(32), primary_key=True)
cron_exp = db.Column(db.String(32))
build_description = db.Column(db.Text)
commands = db.Column(db.Text)
job_id = db.Column(db.Integer, db.ForeignKey("job.id"))
node_id = db.Column(db.Integer, db.ForeignKey("node.id"))
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def to_dict(self):
return {
'cron_key': self.cron_key,
'cron_exp': self.cron_exp,
'build_description': self.build_description,
'commands': self.commands,
'job_id': self.job_id,
'node_id': self.node_id,
'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S")
}
def __repr__(self):
return f"<cron_key {self.cron_key}>"
class Employee(db.Model):
id = db.Column(db.Integer, primary_key=True)
department_id = db.Column(db.Integer, db.ForeignKey("department.id"))
name = db.Column(db.String(250))
surname = db.Column(db.String(250))
slug = db.Column(db.String(250))
salary = db.Column(db.Integer)
birth_date = db.Column(db.Date)
def __init__(self, *args, **kwargs):
super(Employee, self).__init__(*args, **kwargs)
self.slug = slugify(self.name + self.surname)
def __repr__(self):
return f"<Employee : name: {self.name}, surname: {self.surname}, department: {self.department_id}>"
class IpView(db.Model):
__tablename__ = "ip_view"
ip = db.Column("ip", db.String(20), primary_key=True)
date_id = db.Column("date_id",
db.Date(),
db.ForeignKey(Day.id),
primary_key=True)
def __init__(self, ip, date_id):
self.ip = ip
self.date_id = date_id
def serialize(self):
return {"ip": self.ip, "date_id": self.date_id}
class Student(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=False, nullable=False)
surname = db.Column(db.String(30), unique=False, nullable=False)
address = db.Column(db.String(200), unique=False, nullable=True)
year_of_study = db.Column(db.String(2), unique=False, nullable=True)
adm_score = db.Column(db.Float, unique=False, nullable=False)
# Current exam scores for all past years and semesters
scores = db.Column(db.String(200), unique=False, nullable=True)
# Foreign key to a StudyClass instance
study_class_id = db.Column(db.Integer, db.ForeignKey('study_class.id'))
# Foreign key relationship
study_class = db.relationship('StudyClass',
backref=db.backref('students', lazy=True))
def __repr__(self):
return f'{self.name} {self.surname} {self.address} {self.adm_score} {self.scores}'
class Requests(db.Model):
__tablename__ = "requests"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100))
book_id = db.Column(db.Integer, db.ForeignKey("books.id"))
created_on = db.Column(db.DateTime, server_default=db.func.now())
updated_on = db.Column(db.DateTime,
server_default=db.func.now(),
server_onupdate=db.func.now())
def __repr__(self):
return "<User id={}, email={}>, book={}".format(
self.id, self.email, self.book.id)
@property
def serialize(self):
"""Return object data in serializeable format"""
return {
"id": self.id,
"email": self.email,
"book_id": self.book_id,
"timestamp": self.created_on,
}
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
text = db.Column(db.Text, nullable=False)
uuid = db.Column(db.String(255), unique=True)
date = db.Column(db.Date, default=datetime.date.today())
time = db.Column(db.Time, default=datetime.datetime.now().time())
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.uuid = str(uuid.uuid4())
def __repr__(self):
return f"<Post: id={self.id}, author_id={self.author_id}>, text={self.text}, uuid={self.uuid}"
def json(self):
return {
"id": self.id,
"author_id": self.author_id,
"text": self.text,
"uuid": self.uuid,
"date": str(self.date),
"time": str(self.time)
}
class DeliveryUserModel(UserModel):
# table name
__tablename__ = 'delivery_users'
user_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
primary_key=True)
balance = db.Column(db.Integer, nullable=False)
picture = db.Column(db.String(256), nullable=False)
__mapper_args__ = {
'polymorphic_identity': 'delivery_users',
}
# class constructor
def __init__(self, data):
"""
Class constructor
"""
super(DeliveryUserModel, self).__init__(data)
self.balance = data.get('balance')
self.picture = data.get('picture')
@staticmethod
def get_user(user_id):
response = DeliveryUserModel.query.get(user_id)
if not response:
raise NotFoundException("Invalid ID")
return response
@staticmethod
def get_delivery(user_id):
response = DeliveryUserModel.query.get(user_id)
if not response:
raise NotFoundException("Invalid ID")
return response
