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 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 Professor(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)
# Rank of the teacher eg. PhD...
merits = db.Column(db.String(20), unique=False, nullable=False)
# Relationship for foreign key in a different table
study_classes = db.relationship('StudyClass', backref='professor')
discipline = db.relationship('Discipline', backref='professor')
def __repr__(self):
return f'{self.merits} {self.name} {self.surname}'
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 Creator(db.Model):
__tablename__ = 'creator'
id = db.Column(db.Integer(), primary_key=True)
firstName = db.Column(db.String(100))
middleName = db.Column(db.String(100))
lastName = db.Column(db.String(100))
suffix = db.Column(db.String(100))
fullName = db.Column(db.String(100))
modified = db.Column(db.DateTime())
comics = db.relationship(Comics,
secondary=creator_comics,
backref=db.backref('creators', lazy=True))
def __init__(self, id, firstName, middleName, lastName, suffix, fullName,
modified, comics):
self.id = id
self.firstName = firstName
self.middleName = middleName
self.lastName = lastName
self.suffix = suffix
self.fullName = fullName
self.modified = modified
self.comics = comics
def create(self):
db.session.add(self)
db.session.commit()
return self
class UserModel(db.Model,UserMixin):
'''user model : representing user information in sql table'''
__tablename__='users'
id=db.Column(db.Integer,primary_key=True)
email=db.Column(db.String(50),unique=True,nullable=False)
password=db.Column(db.String(256),nullable=False)
mobile_no=db.Column(db.String(10),nullable=False)
billing_address=db.Column(db.Text,nullable=True)
delivery_address=db.Column(db.Text,nullable=True)
products=db.relationship('ProductModel',backref='user',lazy=True,cascade='all,delete')
def __init__(self,email,password,mobile_no):
self.email=email
self.password=bcrypt.generate_password_hash(password).decode('utf-8')
self.mobile_no=mobile_no
def update_password(self,password):
'''update password'''
self.password=bcrypt.generate_password_hash(password).decode('utf-8')
def __repr__(self):
return f"hello i am {self.email}"
def check_password(self,password):
'''check users password'''
return bcrypt.check_password_hash(self.password,password)
class Role(db.Model):
__tablename__ = "roles"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Boolean, default=True, index=True)
permissions = db.Column(db.Integer)
users = db.relationship("User", backref="role", lazy="dynamic")
def __init__(self, **kwargs):
super(Role, self).__init__(**kwargs)
if self.permissions is None:
self.permissions = 0
@staticmethod
def insert_roles():
roles = {
"User": [Permission.FOLLOW, Permission.COMMENT, Permission.WRITE],
"Moderator": [
Permission.FOLLOW,
Permission.COMMENT,
Permission.WRITE,
Permission.MODERATE,
],
"Administrator": [
Permission.FOLLOW,
Permission.COMMENT,
Permission.WRITE,
Permission.MODERATE,
Permission.ADMIN,
],
}
default_role = "User"
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.reset_permissions()
for perm in roles[r]:
role.add_permission(perm)
role.default = role.name == default_role
db.session.add(role)
db.session.commit()
def add_permission(self, perm):
if not self.has_permission(perm):
self.permissions += perm
def remove_permission(self, perm):
if self.has_permission(perm):
self.permissions -= perm
def reset_permissions(self):
self.permissions = 0
def has_permission(self, perm):
return self.permissions & perm == perm
def __repr__(self):
return f"<Role {self.name}>"
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 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 Schedule(db.Model):
id = db.Column(db.Integer, primary_key=True)
# This is where the schedule is written for every week's day
schedule = db.Column(db.String(1000), unique=False, nullable=True)
disciplines = db.relationship('Discipline', backref='schedule')
def __repr__(self):
return f'{self.schedule}'
class Goal(db.Model):
__tablename__ = 'goals'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
description = db.Column(db.String(255))
icon = db.Column(db.String(255))
teachers = db.relationship('Teacher',
secondary=teacher_goals,
back_populates='goals')
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 Hat(db.Model):
__tablename__ = 'hat'
id = db.Column(db.Integer, primary_key=True)
hat_number = db.Column(db.String(100),
index=True,
unique=True,
nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
# Virtual property
names = db.relationship('Name', backref='hat')
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 Teacher(db.Model):
__tablename__ = 'teachers'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
about = db.Column(db.Text)
rating = db.Column(db.Float)
picture = db.Column(db.String(255))
price = db.Column(db.Integer)
goals = db.relationship('Goal',
secondary=teacher_goals,
back_populates='teachers')
free = db.Column(JSON)
class Department(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
slug = db.Column(db.String(255))
employees = db.relationship("Employee")
def __init__(self, *args, **kwargs):
super(Department, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.name:
self.slug = slugify(self.name)
def __repr__(self):
return f"<Department : name={self.name}, id={self.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 Job(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text)
description = db.Column(db.Text)
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
builds = db.relationship('Build', backref='job', lazy=False)
def to_dict(self):
return {
'id': self.id,
'title': self.title,
'description': self.description,
'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S")
}
def __repr__(self):
return f"<id {self.id}, description : {self.description}>"
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 Node(db.Model):
id = db.Column(db.Integer, primary_key=True)
workspace = db.Column(db.Text)
ip_addr = db.Column(db.Text)
port = db.Column(db.Integer)
user = db.Column(db.String(64))
password = db.Column(db.String(64))
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
builds = db.relationship('Build', backref='node', lazy = False)
def to_dict(self):
return {
'id' : self.id,
'workspace' : self.workspace,
'ip_addr': self.ip_addr,
'user' : self.user,
'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S")
}
def __repr__(self):
return f"<id {self.id}, @IP : {self.ip_addr}>"
class CommunityModel(db.Model):
__tablename__ = 'communities'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = 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)
users = db.relationship(
'UserModel',
secondary='community_user_link',
secondaryjoin='and_(CommunityUserLinkModel.user_id == UserModel.id, '
'CommunityUserLinkModel.invitation_accepted == True)')
car_id = db.Column(db.Integer, db.ForeignKey('cars.id'), unique=True)
car = db.relationship("CarModel",
backref=db.backref("community", uselist=False))
is_favourite = None
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'name': fields.String,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'users': fields.List(fields.Nested(UserModel.get_marshaller())),
'car': fields.Nested(CarModel.get_marshaller())
}
@staticmethod
def get_detailed_marshaller():
return {
'id': fields.Integer,
'name': fields.String,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'users': fields.List(fields.Nested(UserModel.get_marshaller())),
'car': fields.Nested(CarModel.get_marshaller()),
'is_deletable': fields.Boolean,
'is_editable': fields.Boolean
}
@staticmethod
def add_is_fav_to_marshaller(marshaller):
marshaller['is_favourite'] = fields.Boolean
return marshaller
@classmethod
def find_by_car_id(cls, id):
return cls.query.filter_by(car_id=id).first()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def return_all(cls):
return CommunityModel.query.all()
@classmethod
def delete_all(cls):
db.session.query(cls).delete()
db.session.commit()
@classmethod
def delete_by_id(cls, id):
community = db.session.query(cls).filter(cls.id == id).first()
if community:
db.session.delete(community)
db.session.commit()
else:
raise NoData
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
email = 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)
cars = db.relationship("CarModel", back_populates="owner")
communities = db.relationship("CommunityModel", secondary='community_user_link')
tours = db.relationship("TourModel", secondary='tour_passenger_link')
reset_password_hash = db.Column(db.String(120), nullable=True, default=None)
reset_password_hash_created = db.Column(db.DateTime(timezone=True), default=None, nullable=True)
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'username': fields.String,
'email': fields.String,
'time_created': fields.DateTime,
'time_updated': fields.DateTime
}
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_by_reset_password_hash(cls, hash):
return cls.query.filter_by(reset_password_hash=hash).first()
@classmethod
def return_all(cls):
return UserModel.query.all()
@classmethod
def delete_all(cls):
db.session.query(cls).delete()
db.session.commit()
@classmethod
def search_by_username(cls, username, excluded_username):
return cls.query \
.filter(UserModel.username.like('%' + username + '%')) \
.filter(UserModel.username != excluded_username) \
.order_by(UserModel.username) \
.limit(10) \
.all()
class TourModel(db.Model):
__tablename__ = 'tours'
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')
start_km = db.Column(db.DECIMAL(precision=(10, 1)), nullable=False)
end_km = db.Column(db.DECIMAL(precision=(10, 1)))
start_time = db.Column(db.DateTime(), nullable=False)
end_time = db.Column(db.DateTime())
parking_position = db.Column(db.String(120))
comment = db.Column(db.String(120))
is_force_finished = db.Column(db.Boolean)
force_finished_by_id = db.Column(db.Integer, db.ForeignKey('users.id'))
force_finished_by = db.relationship('UserModel',
foreign_keys=[force_finished_by_id])
payoff_id = db.Column(db.Integer, db.ForeignKey('payoffs.id'))
is_open = db.Column(db.Boolean, default=True)
passengers = db.relationship('UserModel', secondary='tour_passenger_link')
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,
'start_time':
fields.DateTime,
'end_time':
fields.DateTime,
'owner':
fields.Nested(UserModel.get_marshaller()),
'community':
fields.Nested(CommunityModel.get_marshaller()),
'start_km':
fields.String,
'end_km':
fields.String,
'parking_position':
fields.String,
'comment':
fields.String,
'is_force_finished':
fields.Boolean,
'force_finished_by':
fields.Nested(UserModel.get_marshaller(), allow_null=True),
'is_open':
fields.Boolean,
'passengers':
fields.Nested(UserModel.get_marshaller())
}
@classmethod
def delete_by_id(cls, id):
tour = db.session.query(cls).filter(cls.id == id).first()
if tour:
db.session.delete(tour)
db.session.commit()
else:
raise NoData
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_finished_by_community(cls, community_id):
return cls.query \
.filter_by(community_id=community_id) \
.filter(TourModel.end_km.isnot(None)) \
.order_by(TourModel.end_time.desc()) \
.all()
@classmethod
def find_finished_and_open_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id,
is_open=True).filter(
TourModel.end_km.isnot(None)).all()
@classmethod
def find_finished_by_user(cls, user_id):
return cls.query.filter_by(owner_id=user_id).filter(
TourModel.end_km.isnot(None)).all()
@classmethod
def find_running_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id).filter(
TourModel.end_km.is_(None)).all()
@classmethod
def find_running_by_user(cls, user_id):
return cls.query.filter_by(owner_id=user_id).filter(
TourModel.end_km.is_(None)).all()
@classmethod
def find_newest_tour_for_community(cls, community_id):
return cls.query.filter_by(community_id=community_id).order_by(
TourModel.end_km.desc()).first()
class TaskModel(db.Model):
__tablename__ = 'tasks'
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')
km_interval = db.Column(db.Integer, nullable=True)
km_next_instance = db.Column(db.DECIMAL(precision=10, scale=1), nullable=True)
time_interval = db.Column(db.Interval, nullable=True)
time_next_instance = db.Column(db.DateTime(), nullable=True)
name = db.Column(db.String(120))
description = db.Column(db.String(120))
instances = db.relationship("TaskInstanceModel", cascade="all, delete")
is_reocurrent = db.Column(db.Boolean, nullable=False, default=True)
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,
'time_next_instance': fields.DateTime,
'time_interval': TimedeltaDays,
'owner': fields.Nested(UserModel.get_marshaller()),
'community': fields.Nested(CommunityModel.get_marshaller()),
'name': fields.String,
'description': fields.String,
'km_interval': fields.Integer,
'km_next_instance': fields.Float,
'km_to_next_instance': fields.Float,
'is_reocurrent': fields.Boolean
}
@classmethod
def delete_by_id(cls, task_id):
task = db.session.query(cls).filter(cls.id == task_id).first()
if task:
db.session.delete(task)
db.session.commit()
else:
raise NoData
@classmethod
def find_by_id(cls, task_id):
return cls.query \
.filter_by(id=task_id) \
.first()
@classmethod
def return_all(cls):
return cls.query \
.filter_by(is_reocurrent=True) \
.all()
@classmethod
def find_by_community(cls, community_id):
return cls.query \
.filter_by(community_id=community_id) \
.filter_by(is_reocurrent=True) \
.all()
class CommunityUserLinkModel(db.Model):
__tablename__ = 'community_user_link'
community_id = db.Column(db.Integer,
db.ForeignKey('communities.id'),
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
is_owner = db.Column(db.Boolean, default=True)
invitation_accepted = db.Column(db.Boolean, default=True)
community = db.relationship('CommunityModel')
user = db.relationship('UserModel')
is_favourite = db.Column(db.Boolean, default=False, nullable=False)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
def add_to_session(self):
db.session.add(self)
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'community': fields.Nested(CommunityModel.get_marshaller()),
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
}
@classmethod
def find_by_user_and_community(cls, user_id, community_id):
return cls.query.filter_by(user_id=user_id,
community_id=community_id).first()
@classmethod
def find_favourite_by_user(cls, user_id):
return cls.query.filter_by(user_id=user_id, is_favourite=True).first()
@classmethod
def find_by_user(cls, user_id):
return cls.query.filter_by(user_id=user_id).all()
@classmethod
def find_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id).all()
@classmethod
def find_open_invitations_by_user(cls, user_id):
return cls.query.filter_by(user_id=user_id,
invitation_accepted=False).all()
@classmethod
def find_open_invitations_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id,
invitation_accepted=False).all()
def delete(self):
db.session.delete(self)
db.session.commit()
class Movie(db.Model):
__tablename__ = 'movies'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
description = db.Column(db.String(10000), nullable=False)
duration = db.Column(db.Integer, nullable=False)
poster = db.Column(db.String(1000), nullable=False)
rating = db.Column(db.Float, nullable=False)
year = db.Column(db.Integer, nullable=False)
genre = db.relationship('Genre', secondary=movie_genre_table)
director = db.Column(db.String(50), nullable=True)
def update(self,
id=None,
name=None,
description=None,
duration=None,
poster=None,
rating=None,
year=None,
genre=None,
director=None):
if name is not None:
self.name = name
if description is not None:
self.description = description
if duration is not None:
self.duration = duration
if poster is not None:
self.poster = poster
if rating is not None:
self.rating = rating
if year is not None:
self.year = year
if genre is not None:
for genre_dict in genre:
genre_id = genre_dict.get('id')
genre_in_db = Genre.query.get(genre_id)
if genre_in_db == None:
self.genre.append(Genre.load(genre_dict))
else:
self.genre.append(genre_in_db)
if director is not None:
self.director = director
@classmethod
def load(cls, movie_dict):
movie_model = Movie(name=movie_dict.get('name'),
description=movie_dict.get('description'),
duration=movie_dict.get('duration'),
poster=movie_dict.get('poster'),
rating=movie_dict.get('rating'),
year=movie_dict.get('year'),
director=movie_dict.get('director'))
# Retrieve the json list of Genres of the movie
# If the genre already exists in database then append it to genres list of Movie model
for genre_dict in movie_dict.get('genre'):
genre_id = genre_dict.get('id')
genre_in_db = Genre.query.get(genre_id)
if genre_in_db == None:
movie_model.genre.append(Genre.load(genre_dict))
else:
movie_model.genre.append(genre_in_db)
return movie_model
def dump(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'duration': self.duration,
'poster': self.poster,
'rating': self.rating,
'year': self.year,
'genre': [g.dump() for g in self.genre],
'director': self.director
}
class Room(db.Model):
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.now)
code = db.Column(db.String(8), unique=True)
connections = db.relationship('Connection', backref='room')
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, index=True)
role_id = db.Column(db.Integer, db.ForeignKey("roles.id"))
password_hash = db.Column(db.String(128))
confirmed = db.Column(db.Boolean, default=False)
name = db.Column(db.String(64))
location = db.Column(db.String(64))
about_me = db.Column(db.Text())
housemates = db.Column(db.Text())
significant_others = db.Column(db.Text())
my_five = db.Column(db.Text())
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
last_seen = db.Column(db.DateTime(), default=datetime.utcnow)
avatar_hash = db.Column(db.String(32))
posts = db.relationship("Post", backref="author", lazy="dynamic")
followed = db.relationship(
"Follow",
foreign_keys=[Follow.follower_id],
backref=db.backref(name="follower", lazy="joined"),
lazy="dynamic",
cascade="all, delete-orphan",
)
followers = db.relationship(
"Follow",
foreign_keys=[Follow.followed_id],
backref=db.backref(name="followed", lazy="joined"),
lazy="dynamic",
cascade="all, delete-orphan",
)
@staticmethod
def add_self_follows():
# this is used as a script to go back and add self follows if they are missing
for user in User.query.all():
if not user.is_following(user):
user.follow(user)
db.session.add(user)
db.session.commit()
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if not self.role:
if self.email == current_app.config["MYQ5_ADMIN"]:
self.role = Role.query.filter_by(name="Administrator").first()
if not self.role:
self.role = Role.query.filter_by(default=True).first()
if not self.email and not self.avatar_hash:
self.avatar_hash = self.gravatar_hash()
self.follow(self)
@property
def followed_posts(self):
return Post.query.join(Follow,
Follow.followed_id == Post.author_id).filter(
Follow.follower_id == self.id)
@property
def followed_users(self):
return User.query.join(Follow, Follow.followed_id == User.id).filter(
Follow.follower_id == self.id)
@property
def password(self):
raise AttributeError("password is not a readable attribute")
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def generate_confirmation_token(self, expiration=3600):
s = Serializer(current_app.config["SECRET_KEY"], expiration)
return s.dumps({"confirm": self.id}).decode("utf-8")
def confirm(self, token):
s = Serializer(current_app.config["SECRET_KEY"])
try:
data = s.loads(token.encode("utf-8"))
except Exception:
return False
if data.get("confirm") != self.id:
return False
self.confirmed = True
db.session.add(self)
return True
def generate_reset_token(self, expiration=3600):
s = Serializer(current_app.config["SECRET_KEY"], expiration)
return s.dumps({"reset": self.id}).decode("utf-8")
@staticmethod
def reset_password(token, new_password):
s = Serializer(current_app.config["SECRET_KEY"])
try:
data = s.loads(token.encode("utf-8"))
except:
return False
user = User.query.get(data.get("reset"))
if user is None:
return False
user.password = new_password
db.session.add(user)
return True
def generate_email_change_token(self, new_email, expiration=3600):
s = Serializer(current_app.config["SECRET_KEY"], expiration)
return s.dumps({
"change_email": self.id,
"new_email": new_email
}).decode("utf-8")
def change_email(self, token):
s = Serializer(current_app.config["SECRET_KEY"])
try:
data = s.loads(token.encode("utf-8"))
except:
return False
if data.get("change_email") != self.id:
return False
new_email = data.get("new_email")
self.avatar_hash = self.gravatar_hash()
if new_email is None:
return False
if self.query.filter_by(email=new_email).first() is not None:
return False
self.email = new_email
db.session.add(self)
return True
def can(self, perm):
return self.role is not None and self.role.has_permission(perm)
def is_administrator(self):
return self.can(Permission.ADMIN)
def ping(self):
self.last_seen = datetime.utcnow()
db.session.add(self)
def gravatar_hash(self):
return hashlib.md5(self.email.lower().encode("utf-8")).hexdigest()
def gravatar(self, size=100, default="identicon", rating="g"):
url = "https://secure.gravatar.com/avatar"
gravatar_hash = self.avatar_hash or self.gravatar_hash()
return f"{url}/{gravatar_hash}?s={size}&d={default}&r={rating}"
def follow(self, user):
if not self.is_following(user):
f = Follow(follower=self, followed=user)
db.session.add(f)
def unfollow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
db.session.delete(f)
def is_following(self, user):
if user.id is None:
return False
return self.followed.filter_by(followed_id=user.id).first() is not None
def is_followed_by(self, user):
if user.id is None:
return False
return self.followers.filter_by(
follower_id=user.id).first() is not None
def __repr__(self):
return f"<User {self.username}>"
class DebtModel(db.Model):
__tablename__ = 'debts'
id = db.Column(db.Integer, primary_key=True)
is_settled = db.Column(db.Boolean, default=False)
amount = db.Column(db.DECIMAL(10, 2), nullable=False)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
debtee_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
debtee = db.relationship('UserModel', foreign_keys=[debtee_id])
recepient_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
recepient = db.relationship('UserModel', foreign_keys=[recepient_id])
payoff_id = db.Column(db.Integer,
db.ForeignKey('payoffs.id'),
nullable=False)
community_id = db.Column(db.Integer,
db.ForeignKey('communities.id'),
nullable=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,
'debtee': fields.Nested(UserModel.get_marshaller()),
'recepient': fields.Nested(UserModel.get_marshaller()),
'is_settled': fields.Boolean,
'amount': fields.Float
}
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id).all()
@classmethod
def find_unsettled_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id,
is_settled=False).all()
@classmethod
def find_unsettled_by_user(cls, user_id):
return cls.query.filter(((DebtModel.recepient_id == user_id) |
(DebtModel.debtee_id == user_id)),
DebtModel.is_settled == False).all()
@classmethod
def find_unsettled_by_payoff(cls, payoff_id):
return cls.query.filter_by(payoff_id=payoff_id, is_settled=False).all()
