class IncidentAssignedToRelevantAgencies(db.Model):
_tablename_ = "incident_assigned_to_relevant_agencies"
# Attributes
agency_id = db.Column(db.Integer, db.ForeignKey('relevant_agency.agencyid'), primary_key=True)
incidentID = db.Column(db.Integer, db.ForeignKey('incident.incidentID'), primary_key=True)
link = db.Column(db.String(255))
ackTimeStamp = db.Column(db.DateTime)
# Relationships
incident = db.relationship('Incident', backref=db.backref("incident_assigned_to_relevant_agencies", cascade="all, delete-orphan"))
relevantAgency = db.relationship("RelevantAgency", backref=db.backref("relevant_agency"))
class IncidentHasStatus(db.Model):
__tablename__ = 'incident_has_status'
statusTime = db.Column(db.DateTime, primary_key=True, nullable=False, default=sgtimestampnow)
statusID = db.Column(db.Integer, db.ForeignKey('status.statusID'))
incidentID = db.Column(db.Integer, db.ForeignKey('incident.incidentID'))
# Relationships
incident = db.relationship('Incident', backref=db.backref("incident_has_status", cascade="all, delete-orphan"))
status = db.relationship("Status", backref=db.backref("incidents"))
def __init__(self, **kwargs):
super(IncidentHasStatus, self).__init__(**kwargs)
class Books(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
authors = db.relationship('Author',
secondary=authors,
backref=db.backref('authors', lazy='dynamic'))
published_date = db.Column(db.String(5), nullable=True)
categories = db.relationship('Category',
secondary=categories,
backref=db.backref('categories',
lazy='dynamic'))
average_rating = db.Column(db.String(10), nullable=True)
ratings_count = db.Column(db.String(10), nullable=True)
thumblnail = db.Column(db.String(100), nullable=True)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer,
db.ForeignKey('profile.id', ondelete='CASCADE'),
nullable=False)
content = db.Column(db.String(280), nullable=False)
location = db.Column(db.String(40), nullable=True)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
image = db.Column(db.String(20), nullable=True)
comments = db.relationship('Comment',
cascade="all, delete-orphan",
backref='post')
likes = db.relationship('Profile',
secondary=likes,
lazy='subquery',
backref=db.backref('likes', lazy=True))
def add_image(self, image_data):
picture_file_name = save_image(image_data,
app.config['UPLOAD_FOLDER_POSTS_IMGS'],
(510, 515))
self.image = picture_file_name
def delete_image(self):
if self.image:
delete_image(app.config['UPLOAD_FOLDER_POSTS_IMGS'], self.image)
self.image = None
def __repr__(self):
return f"Post({self.id}, '{self.author_id}', '{self.content}', '{self.location}', '{self.date_posted}', '{self.image}')"
def __str__(self):
return f"Post(#{self.id})"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
ques = db.Column(db.String(150), nullable=False)
answers = db.relationship('Ans', backref=db.backref('question'), lazy=True)
def __repr__(self):
return f"post('{self.ques}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(60), nullable=False)
lastname = db.Column(db.String(60), nullable=False)
email = db.Column(db.String(60), nullable=False)
dob = db.Column(db.Date, nullable=False)
password = db.Column(db.String(60), nullable=False)
number = db.Column(db.String(13), nullable=False)
confirmed = db.Column(db.Boolean, default=False, nullable=False)
admin = db.Column(db.Boolean, default=False, nullable=False)
courses = db.relationship('Course',
secondary=subs,
lazy='dynamic',
backref=db.backref('subscribers', lazy=True))
answer = db.relationship('Ans', backref=db.backref('author'), lazy=True)
def __repr__(self):
return f"User('{self.email}','{self.firstname}','{self.lastname}','{self.dob}','{self.number}','{self.confirmed}')"
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(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
roles = db.relationship('Role',
secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
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(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
cards = db.relationship('Card',
secondary=user_card_assoc,
backref=db.backref('owners'),
lazy='dynamic')
def __repr__(self):
return 'User:' + self.username
class Role(db.Model):
__tablename__ = 'roles'
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(64), unique=True, nullable=False)
description = db.Column(db.String(222))
rel_emp = db.relationship('Employee',
secondary=user_role,
backref=db.backref('role', lazy='dynamic'))
def __repr__(self):
return self.role_name
class Card(db.Model):
__tablename__ = 'card'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=True, nullable=False)
power = db.Column(db.Integer)
toughness = db.Column(db.Integer)
manaCost = db.Column(db.String(10))
image = db.Column(db.String(80),
nullable=False,
default='default_card.jpg')
card_types = db.relationship('CardType',
secondary=card_type_assoc,
backref=db.backref('cards'),
lazy='dynamic')
card_sub_types = db.relationship('CardSubType',
secondary=card_sub_type_assoc,
backref=db.backref('cards'),
lazy='dynamic')
def __repr__(self):
return 'Card:' + self.name
class Clazz(db.Model, DictModel):
__tablename__ = 't_class'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
# 该属性查询"User"时，
# db.backref('clazz', lazy='joined')该属性会级联把Clazz类的信息查询出来，
# 并赋值给backref的第一个参数即"clazz",关联类(User)会自动添加一个动态属性clazz
users = db.relationship('User', backref=db.backref('clazz', lazy='joined'), lazy='dynamic')
school_id = db.Column(db.Integer, db.ForeignKey('t_school.id'))
def __init__(self, **kwargs):
self.name = kwargs.pop('name', None)
def __repr__(self):
return '<Clazz %r>' % self.name
class School(db.Model, DictModel):
__tablename__ = 't_school'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
address = db.Column(db.String(80), unique=True, nullable=False)
# 该属性查询"Clazz"时，
# db.backref('school', lazy='joined')该属性会级联把School类的信息查询出来，
# 并赋值给backref的第一个参数即"clazz",关联类(Clazz)会自动添加一个动态属性school
classes = db.relationship('Clazz', backref=db.backref('school', lazy='joined'), lazy='dynamic')
def __init__(self, **kwargs):
self.name = kwargs.pop('name', None)
self.address = kwargs.pop('address', None)
def __repr__(self):
return '<School %r>' % self.name
class Employee(db.Model, UserMixin):
__tablename__ = 'employees'
emp_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, nullable=False)
email = db.Column(db.String(64), unique=True, nullable=False)
firstname = db.Column(db.String(64), nullable=False)
lastname = db.Column(db.String(64), nullable=False)
password = db.Column(db.String(64), nullable=False)
dept_id = db.Column(db.Integer, db.ForeignKey('departments.dept_id'))
is_leader = db.Column(db.Boolean, default=False)
rel_roles = db.relationship('Role',
secondary=user_role,
backref=db.backref('employee', lazy='dynamic'))
def get_id(self):
return self.emp_id
def __repr__(self):
return self.username
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(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
admin = db.Column(db.String(1), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
favorites = db.relationship('AnimeSeries',
secondary=favorites,
backref=db.backref('favorites',
lazy='dynamic'))
ratings = db.relationship('UserRating',
backref='favorites',
lazy='dynamic')
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model, UserMixin):
__tablename__ = 'users'
uid = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(32), nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comment', backref='author', lazy=True)
follows = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.user_id == uid),
secondaryjoin=(followers.c.follows_id == uid),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
notifs = db.relationship('Notif', backref='notif_for', lazy=True)
notif_count = db.Column(db.Integer, default=0)
def get_notifs(self):
if self.new_notif():
limit = len(self.notifs) - self.notif_count
# print(len(self.notifs), self.notif_count)
l = self.notifs[-limit:]
l.reverse()
return l
def get_old_notifs(self):
limit = len(self.notifs) - self.notif_count
self.notif_count = len(self.notifs)
db.session.commit()
if limit == 0:
l = self.notifs[-4:]
else:
l = self.notifs[-4:-limit]
l.reverse()
return l
# print(self.notif_count, self.notifs[-4:])
def new_notif(self):
return len(self.notifs) > self.notif_count
def post_count(self):
return len(self.posts)
def get_id(self):
return self.uid
def is_following(self, user):
l = self.follows.filter(followers.c.follows_id == user.uid).count()
return l > 0
def follow(self, user):
if self.uid != user.uid:
if not self.is_following(user):
self.follows.append(user)
def unfollow(self, user):
if self.is_following(user):
self.follows.remove(user)
def get_followers(self, user):
return User.query.filter(User.follows.any(uid=user.uid)).all()
def get_followers_count(self, user):
return len(self.get_followers(user))
def get_followed_posts(self):
fw_users = [user.uid for user in self.follows.all()]
fw_users.append(self.uid) # to include my own posts
# print(fw_users)
fw_posts = Post.query.order_by(Post.date_posted.desc()).filter(
Post.user_id.in_(fw_users))
return fw_posts
def get_user_suggestion(self):
user_follows = self.follows
avoid = [user.uid for user in user_follows]
avoid.append(self.uid)
available_users = User.query.filter(User.uid.notin_(avoid)).all()
if len(available_users) == 0:
return []
elif len(available_users) <= 2:
return available_users
# find sugg users
suggs = []
while len(suggs) < 2:
index = random.randint(0, len(available_users) - 1)
user = available_users[index]
if user not in suggs:
suggs.append(user)
# print(suggs)
return suggs
def __repr__(self):
return f"User('{self.username}', '{self.password}', '{self.image_file}')"
class Profile(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
bio = db.Column(db.String(300), nullable=True)
city = db.Column(db.String(100), nullable=True)
website = db.Column(db.String(40), nullable=True)
# Users have to have at least default img, so nullable=False.
image = db.Column(db.String(20), nullable=False, default='default.jpg')
posts = db.relationship('Post',
cascade="all, delete-orphan",
backref='author')
comments = db.relationship('Comment',
cascade="all, delete-orphan",
backref='author')
'''
* Profile is the right side entity of the relationship (the left side entity is the parent class).
Since this is a self-referential relationship, I have to use the same class on both sides.
* secondary configures the association table that is used for this relationship,
which I defined right above this class.
* primaryjoin indicates the condition that links the left side entity (the follower user) with the association table.
The join condition for the left side of the relationship is the user ID matching the follower_id field of the association table.
The followers.c.follower_id expression references the follower_id column of the association table.
* secondaryjoin indicates the condition that links the right side entity (the followed user) with the association table.
This condition is similar to the one for primaryjoin, with the only difference that now I'm using followed_id,
which is the other foreign key in the association table.
* backref defines how this relationship will be accessed from the right side entity.
From the left side, the relationship is named followed, so from the right side I am going to use the name followers
to represent all the left side users that are linked to the target user in the right side.
The additional lazy argument indicates the execution mode for this query.
A mode of dynamic sets up the query to not run until specifically requested, which is also how I set up the posts one-to-many relationship.
* lazy is similar to the parameter of the same name in the backref, but this one applies to the left side query instead of the right side.'
'''
followed = db.relationship('Profile',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def add_image(self, image_data):
app.logger.debug(self.image)
picture_file_name = save_image(
image_data, app.config['UPLOAD_FOLDER_PROFILES_IMGS'][0],
(125, 125))
self.image = picture_file_name
def delete_image(self):
if self.image != 'default.jpg':
delete_image(app.config['UPLOAD_FOLDER_PROFILES_IMGS'][0],
self.image)
self.image = 'default.jpg'
def set_default_image(self):
self.delete_image()
self.image = 'default.jpg'
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
self.followed_posts()
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def is_followed_by(self, user):
return self.followers.filter(
followers.c.follower_id == user.id).count() > 0
def followed_posts(self):
return Post.query.join(
followers, (followers.c.followed_id == Post.author_id)).filter(
followers.c.follower_id == self.id).order_by(
Post.date_posted.desc()).all()
def user_and_followed_posts(self):
return Post.query.join(
followers, (followers.c.followed_id == Post.author_id)).filter(
or_(followers.c.follower_id == self.id,
Post.author_id == self.id)).order_by(
Post.date_posted.desc()).all()
def user_posts(self):
return Post.query.filter_by(author_id=self.id).order_by(
Post.date_posted.desc()).all()
def __str__(self):
return f"Profile(#{self.id} of {self.user})"