class FollowUp(db.Model):
__tablename__ = "followup"
id = db.Column(db.Integer, primary_key=True)
followupInstructions = db.Column(db.Text)
specialInvestigations = db.Column(db.Text)
diagnosis = db.Column(db.Text)
treatment = db.Column(db.Text)
medicationPrescribed = db.Column(db.Text)
dateAssessed = db.Column(db.BigInteger, nullable=False)
followupNeeded = db.Column(db.Boolean)
# FOREIGN KEYS
readingId = db.Column(db.ForeignKey(Reading.readingId), nullable=False)
healthcareWorkerId = db.Column(db.ForeignKey(User.id), nullable=False)
# RELATIONSHIPS
reading = db.relationship(
Reading,
backref=db.backref(
"followup", lazy=True, uselist=False, cascade="all, delete-orphan"
),
)
healthcareWorker = db.relationship(User, backref=db.backref("followups", lazy=True))
@staticmethod
def schema():
return FollowUpSchema
class Project(db.Model):
__tablename__ = 'project'
id = db.Column(db.Integer(), primary_key=True, comment='主键，自增')
user_id = db.Column(db.Integer(), nullable=True, comment='所属的用户id')
name = db.Column(db.String(64), nullable=True, unique=True, comment='项目名称')
host = db.Column(db.String(1024), nullable=True, comment='测试环境')
host_two = db.Column(db.String(1024), comment='开发环境')
host_three = db.Column(db.String(1024), comment='线上环境')
host_four = db.Column(db.String(1024), comment='备用环境')
environment_choice = db.Column(db.String(16), comment='环境选择，first为测试，以此类推')
principal = db.Column(db.String(16), nullable=True)
variables = db.Column(db.String(2048), comment='项目的公共变量')
headers = db.Column(db.String(1024), comment='项目的公共头部信息')
func_file = db.Column(db.String(64),
nullable=True,
unique=True,
comment='函数文件')
modules = db.relationship('Module',
order_by='Module.num.asc()',
lazy='dynamic')
configs = db.relationship('Config',
order_by='Config.num.asc()',
lazy='dynamic')
case_sets = db.relationship('CaseSet',
order_by='CaseSet.num.asc()',
lazy='dynamic')
created_time = db.Column(db.DateTime,
index=True,
default=datetime.now,
comment='创建时间')
update_time = db.Column(db.DateTime,
index=True,
default=datetime.now,
onupdate=datetime.now)
class UpVote(DaoOperations, OutputMixin, db.Model):
RELATIONSHIPS_TO_DICT = True
UPVOTE_REQUIRED_PARAMS = ['user_id', 'dish_id']
vid = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.String(50))
user_id = db.Column(db.Integer, db.ForeignKey('user.uid'), nullable=False)
user = db.relationship('User', backref='upvotes', lazy=True)
dish_id = db.Column(db.Integer, db.ForeignKey('dish.did'), nullable=False)
dish = db.relationship('Dish', backref='upvotes', lazy=True)
def __init__(self, **kwargs):
super(UpVote, self).__init__(**kwargs)
self.timestamp = kwargs.get('timestamp', datetime.utcnow().strftime('%d/%m/%Y %I:%M:%S %p'))
self.user_id = kwargs['user_id']
self.dish_id = kwargs['dish_id']
@staticmethod
def get_all_upvotes():
return UpVote.query.all()
@staticmethod
def get_all_user_upvotes(uid):
return UpVote.query.filter_by(user_id=uid)
@staticmethod
def get_all_dish_upvotes(did):
return UpVote.query.filter_by(dish_id=did)
@staticmethod
def get_upvote_by_id(oid):
return UpVote.query.filter_by(vid=oid).first()
class User_Order(db.Model):
__tablename__='user_order'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=[user_id], backref= db.backref('user_order'), cascade='all')
order_id = db.Column(db.Integer, db.ForeignKey('orders.id'))
order = db.relationship('Order', foreign_keys=[order_id], backref=db.backref('user_order'), cascade='all')
class Hangar(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(254), nullable=False)
country = db.Column(db.String(254), nullable=False)
pilot_id = db.Column(db.Integer, db.ForeignKey(Pilot.id), nullable=False)
pilot = db.relationship("Pilot")
helicopter_id = db.Column(db.Integer,
db.ForeignKey(HelicopteroDeCombate.id),
nullable=False)
helicopter = db.relationship("HelicopteroDeCombate")
def __str__(self):
return f'''{self.id} - {self.name}, {self.country};
Piloto: {self.pilot_id} - {self.pilot};
Helicóptero: {self.helicopter_id} - {self.helicopter}'''
def json(self):
return {
"id": self.id,
"name": self.name,
"country": self.country,
"pilot_id": self.pilot_id,
"pilot": self.pilot.json(),
"helicopter_id": self.helicopter_id,
"helicopter": self.helicopter.json()
}
class Meal(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(45))
total_calories = db.Column(db.Float, default=0)
total_fat = db.Column(db.Float, default=0)
total_carbs = db.Column(db.Float, default=0)
total_protein = db.Column(db.Float, default=0)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='cascade'), nullable=False)
user = db.relationship('User', foreign_keys=[user_id])
food_items = db.relationship('Food', back_populates='meal', cascade='all, delete, delete-orphan')
@classmethod
def meal_exists(cls, user_data):
all_meals = Meal.query.filter_by(user_id=session['user_id']).filter_by(name=user_data['meal_name'])
print(all_meals)
meal = ''
for m in all_meals:
if m.created_at.astimezone().strftime('%Y-%m-%d') == local_time.strftime('%Y-%m-%d'):
meal = m
print(meal)
if meal != '':
return meal
elif meal == '':
return False
class RoleData(db.Model, Serializer):
__tablename__ = 'role'
id = db.Column('role_id', db.Integer, primary_key=True)
name = db.Column('name', db.Unicode(255))
description = db.Column('description', db.Unicode(255))
timestamp = db.Column('timestamp',
db.TIMESTAMP,
server_default=db.func.current_timestamp(),
nullable=False)
permissions = db.relationship('PermissionData',
secondary=role_permission,
lazy='dynamic',
backref=db.backref('roles', lazy='dynamic'))
journey_versions = db.relationship('JourneyVersionData',
secondary=journey_version_role,
lazy='dynamic',
backref=db.backref('roles',
lazy='dynamic'))
def __init__(self, args):
for arg in args:
setattr(self, arg, args[arg])
def serialize(self):
return {
'id': self.id,
'name': self.name,
'description': self.description
}
class Listing(db.Model):
__tablename__ = 'listings'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey("users.id",
ondelete="cascade",
onupdate='cascade'),
nullable=False)
location_from = db.Column(db.String())
location_to = db.Column(db.String())
description = db.Column(db.String())
date = db.Column(db.DateTime)
price = db.Column(db.String)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
user = db.relationship('User',
foreign_keys=[user_id],
backref="user_listings")
users_request_this_listing = db.relationship('User',
secondary=requests,
lazy='dynamic',
backref=db.backref('listings',
lazy=True))
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(32))
image = db.Column(db.Text)
text = db.Column(db.Text)
position = db.Column(db.String(64))
start = db.Column(db.String(32))
days = db.Column(db.String(16))
people = db.Column(db.String(32))
pay = db.Column(db.String(32))
thumb = db.Column(db.Integer)
collection = db.Column(db.Integer)
comment = db.relationship('Comment',
backref='owner_article',
cascade='all, delete-orphan',
passive_deletes=True)
thumb_list = db.relationship('Thumb',
backref='owner_article',
cascade='all, delete-orphan',
passive_deletes=True)
collection_list = db.relationship('Collection',
backref='owner_article',
cascade='all, delete-orphan',
passive_deletes=True)
article_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
time = db.Column(db.DateTime, default=datetime.now)
def __repr__(self):
return '<Article %r>' % self.id
class Pizzas(db.Model):
__tablename__ = "pizzas"
id = db.Column(db.Integer, primary_key=True)
crust = db.Column(db.String(14))
size = db.Column(db.String(10))
method = db.Column(db.String(13))
users_who_like = db.relationship("Users", secondary=favorites)
toppings = db.relationship("Toppings", secondary=pizza_has_toppings)
created_at = db.Column(db.DateTime, default=datetime.utcnow())
updated_at = db.Column(db.DateTime, default=datetime.utcnow())
# Add new pizza to order
@classmethod
def add_pizza(cls, user_info):
added_toppings = user_info.getlist('topping')
newPizza = cls(crust=user_info['crust'],
size=user_info['size'],
method=user_info['method'])
db.session.add(newPizza)
db.session.commit()
this_pizza = cls.query.get(newPizza.id)
for topping in added_toppings:
this_topping = Toppings.query.get(topping)
this_pizza.toppings.append(this_topping)
db.session.commit()
session['order'].append(this_pizza.id)
session['ordercount'] += 1
flash("Pizza added to cart!", "info")
class Language(db.Model):
__tablename__ = "languages"
lang_id = db.Column(db.Integer, primary_key=True)
lang_name = db.Column(db.String(20))
devs = db.relationship("Developer", secondary=lang_table)
positions = db.relationship("Position", secondary=position_lang)
def fillLangauges():
langs = [
"HTML", "CSS", "Ruby", "Python", "JavaScript", "Java", "C#", "C++",
"SQL", "Django", "Flask", "Rails"
]
for lang in langs:
add_lang = Language(lang_name=lang)
db.session.add(add_lang)
db.session.commit()
verify = "success"
return verify
# class Framework(db.Model):
# __tablename__="frameworks"
# framework_id = db.Column(db.Integer, primary_key=True)
# frame_name = db.Column(db.String(50))
# def fillFrameworks():
# fws = ["django","flask","rails","spring","sql","ember","jquery","boostrap"]
# for fw in fws:
# add_fw = Framework(frame_name=fw)
# db.session.add(add_fw)
# db.session.commit()
# verify = "success"
# return verify
class User(db.Model):
__tablename__ = 'user'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(40), nullable=False)
Lastname = db.Column(db.String(40), nullable=False)
email = db.Column(db.String(40), nullable=False)
phone = db.Column(db.Integer, unique=True, nullable=False)
details = db.relationship('Details', backref='user', uselist=False)
password = db.relationship('Credential', backref='user', uselist=False)
roll = db.Column(db.String(4), nullable=False)
def __init__(self, firstname, lastname, email, phone, address, dob,
password, roll):
self.email = email
self.roll = roll
self.firstname = firstname
self.Lastname = lastname
self.phone = phone
self.details = Details(user_id=self.id, address=address, dob=dob)
self.password = Credential(user_id=self.id, password=password)
def serialize(self):
# print(self.details[0].serialize())
data = {'id': self.id, 'firstname': self.firstname}
return data
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(25))
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(128))
# FOREIGN KEYS
healthFacilityName = db.Column(
db.String(50), db.ForeignKey("healthfacility.healthFacilityName"), nullable=True
)
# RELATIONSHIPS
healthFacility = db.relationship(
"HealthFacility", backref=db.backref("users", lazy=True)
)
roleIds = db.relationship(
"Role", secondary=userRole, backref=db.backref("users", lazy=True)
)
referrals = db.relationship("Referral", backref=db.backref("users", lazy=True))
vhtList = db.relationship(
"User",
secondary=supervises,
primaryjoin=id == supervises.c.choId,
secondaryjoin=id == supervises.c.vhtId,
)
@staticmethod
def schema():
return UserSchema
def __repr__(self):
return "<User {}>".format(self.username)
class PatientAssociations(db.Model):
id = db.Column(db.Integer, primary_key=True)
patientId = db.Column(
db.ForeignKey(Patient.patientId, ondelete="CASCADE"),
nullable=False,
)
healthFacilityName = db.Column(
db.ForeignKey(HealthFacility.healthFacilityName, ondelete="CASCADE"),
nullable=True,
)
userId = db.Column(db.ForeignKey(User.id, ondelete="CASCADE"), nullable=True)
# RELATIONSHIPS
patient = db.relationship(
"Patient",
backref=db.backref("associations", lazy=True, cascade="all, delete"),
)
healthFacility = db.relationship(
"HealthFacility",
backref=db.backref("associations", lazy=True, cascade="all, delete"),
)
user = db.relationship(
"User",
backref=db.backref("associations", lazy=True, cascade="all, delete"),
)
@staticmethod
def schema():
return PatientAssociationsSchema
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
contactEmail = db.Column(db.String, unique=True, nullable=False)
image_file = db.Column(db.Text)
description = db.Column(db.Text, nullable=True, default='')
tel = db.Column(db.String(15), default='')
posts = db.relationship('Post', backref='Author', lazy=True)
favorites = db.relationship('User_has_Post_as_favorite',
backref='Author',
lazy=True)
def __init__(self, name, password, email, contactEmail, image_file, cell,
aboutMe):
self.name = name
self.password = generate_password_hash(password)
self.email = email
self.contactEmail = contactEmail
self.image_file = image_file
self.tel = cell
self.description = aboutMe
def __repr__(self):
return f"User('{self.name}','{self.email}','{self.image_file}')"
def verify_password(self, pwd):
return check_password_hash(self.password, pwd)
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(64), unique=True)
name = db.Column(db.String(16))
password = db.Column(db.String(32))
sex = db.Column(db.String(16), default='保密')
avatar = db.Column(db.String(64), default='/static/timg.jpg')
article = db.relationship('Article',
backref='owner_user',
cascade='all, delete-orphan',
passive_deletes=True)
comment = db.relationship('Comment',
backref='owner_user',
cascade='all, delete-orphan',
passive_deletes=True)
reply = db.relationship('Reply',
backref='owner_user',
cascade='all, delete-orphan',
passive_deletes=True)
thumb_list = db.relationship('Thumb',
backref='owner_user',
cascade='all, delete-orphan',
passive_deletes=True)
collection_list = db.relationship('Collection',
backref='owner_user',
cascade='all, delete-orphan',
passive_deletes=True)
def __repr__(self):
return '<User %r>' % self.id
class User(db.Model):
__tablename__ = "users"
user_id = db.Column(db.Integer, primary_key = True)
f_name = db.Column(db.String(45))
l_name = db.Column(db.String(45))
email = db.Column(db.String(45))
password = db.Column(db.String(255))
admin_status = db.Column(db.Integer)
profile = db.Column(db.String(1600))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
liked_idea = db.relationship("Idea", secondary = "user_likes")
friends=db.relationship("User",
secondary=friends_table,
primaryjoin=user_id==friends_table.c.friendee_id,
secondaryjoin=user_id==friends_table.c.friender_id,
backref="friending")
blocked=db.relationship("User",
secondary=block_list,
primaryjoin=user_id==block_list.c.blockee_id,
secondaryjoin=user_id==block_list.c.blocker_id,
backref="blocking")
def create_admin(self):
admin = User(
f_name= "Admin",
l_name= "Admin",
email = "admin",
admin_status = 1,
password = self)
db.session.add(admin)
db.session.commit()
class Enrollment(db.Model):
__tablename__ = 'enrollments'
id = db.Column(db.Integer, primary_key=True)
student_id = db.Column(db.Integer, db.ForeignKey('students.id'), nullable=False)
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'), nullable=False)
course = db.relationship("Course", backref="students_enrolled")
student = db.relationship("Student", backref="classes_enrolled")
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), unique=False, nullable=False)
url = db.Column(db.String(300), unique=False, nullable=False)
receiver_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
receiver = db.relationship('User',
foreign_keys=receiver_id,
backref=db.backref('received_articles',
lazy=True))
sender_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
sender = db.relationship('User',
foreign_keys=sender_id,
backref=db.backref('sent_articles', lazy=True))
def __repr__(self):
return '<Article %r>' % self.title
def serialize(self):
data = {
"id": self.id,
"title": self.title,
"url": self.url,
"sender_id": self.sender_id,
"receiver_id": self.receiver_id,
}
return json.dumps(data)
class Referral(db.Model):
id = db.Column(db.Integer, primary_key=True)
dateReferred = db.Column(db.BigInteger, nullable=False)
comment = db.Column(db.Text)
actionTaken = db.Column(db.Text)
# FOREIGN KEYS
userId = db.Column(db.Integer, db.ForeignKey('user.id'))
patientId = db.Column(db.String(50), db.ForeignKey('patient.patientId'))
referralHealthFacilityName = db.Column(
db.String(50), db.ForeignKey('healthfacility.healthFacilityName'))
readingId = db.Column(db.String(50), db.ForeignKey('reading.readingId'))
followUpId = db.Column(db.Integer, db.ForeignKey('followup.id'))
# RELATIONSHIPS
healthFacility = db.relationship('HealthFacility',
backref=db.backref('referrals',
lazy=True))
reading = db.relationship('Reading',
backref=db.backref('referral',
lazy=True,
uselist=False))
followUp = db.relationship('FollowUp',
backref=db.backref('referral',
lazy=True,
uselist=False,
cascade="save-update"))
class Orders_Topping(db.Model):
__tablename__='orders_topping'
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('orders.id'))
order = db.relationship('Order', foreign_keys=[order_id], backref=db.backref('orders_topping'), cascade='all')
topping_id = db.Column(db.Integer, db.ForeignKey('toppings.id'))
topping = db.relationship('Topping', foreign_keys=[topping_id], backref=db.backref('orders_topping'), cascade='all')
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(25))
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(128))
# FOREIGN KEYS
healthFacilityName = db.Column(
db.String(50),
db.ForeignKey('healthfacility.healthFacilityName'),
nullable=True)
# RELATIONSHIPS
healthFacility = db.relationship('HealthFacility',
backref=db.backref('users', lazy=True))
roleIds = db.relationship('Role',
secondary=userRole,
backref=db.backref('users', lazy=True))
referrals = db.relationship('Referral',
backref=db.backref('users', lazy=True))
vhtList = db.relationship('User',
secondary=supervises,
primaryjoin=id == supervises.c.choId,
secondaryjoin=id == supervises.c.vhtId)
def __repr__(self):
return '<User {}>'.format(self.username)
class Info(db.Model):
id = db.Column(db.Integer, primary_key=True)
geonameid = db.Column(db.Integer, unique=True)
name = db.Column(db.String(64), unique=False, nullable=False)
asciiname = db.Column(db.String(64), unique=False, nullable=False)
alternatenames = db.Column(db.String(256), unique=False, nullable=True)
latitude = db.Column(db.String(64), unique=False, nullable=False)
longitude = db.Column(db.String(256), unique=False)
feature_class = db.Column(db.String(1), unique=False, nullable=False)
feature_code = db.Column(db.String(10), unique=False, nullable=False)
country_code = db.Column(db.String(2), unique=False, nullable=False)
cc2 = db.Column(db.String(200), unique=False, nullable=False)
admin1_code = db.Column(db.String(20), unique=False, nullable=False)
admin2_code = db.Column(db.String(80), unique=False, nullable=False)
admin3_code = db.Column(db.String(20), unique=False, nullable=False)
admin4_code = db.Column(db.String(20), unique=False, nullable=False)
population = db.Column(db.Integer, unique=False)
elevation = db.Column(db.Integer, unique=False)
dem = db.Column(db.Integer, unique=False)
timezone = db.Column(db.String(40), unique=False, nullable=False)
modification_date = db.Column(db.String(40), unique=False, nullable=False)
id_link = db.relationship('NameId', backref='idlnk', lazy='dynamic')
timezone_offset = db.relationship('Timezones',
backref='timezone',
uselist=False)
class Like(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user_who_liked_quote = db.relationship('User',
foreign_keys=[user_id],
backref='user_liked',
cascade='all')
quote_id = db.Column(db.Integer, db.ForeignKey('quote.id'))
quote_liked_by_user = db.relationship('Quote',
foreign_keys=[quote_id],
backref='liked_quote',
cascade='all')
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
@classmethod
def like_quote(cls, like_quote):
add_like = cls(user_id=like_quote["login_id"],
quote_id=like_quote["liked_quote_value"])
db.session.add(add_like)
db.session.commit()
flash("You liked a quote!")
return add_like
class Users(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255), nullable=True)
last_name = db.Column(db.String(255), nullable=True)
prefix = db.Column(db.String(255), nullable=True)
group = db.Column(db.String(255), nullable=True)
username = db.Column(db.String(255), nullable=True)
password = db.Column(db.String(255), nullable=True)
mobileNumber = db.Column(db.String(255), nullable=True)
mobileNumberExtension = db.Column(db.String(255), nullable=True)
email = db.Column(db.String(255), nullable=True)
citizenId = db.Column(db.String(255), nullable=True)
status = db.Column(db.String(255), nullable=True)
groupName = db.Column(db.String(255), nullable=True)
verified = db.Column(db.Boolean(), nullable=True)
token = db.Column(db.String(255), nullable=True)
lockedOut = db.Column(db.Boolean(), nullable=True)
passwordExpired = db.Column(db.Boolean(), nullable=True)
officeNumber = db.Column(db.String(255), nullable=True)
createdAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
updatedAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
roleId = db.Column(db.Integer, db.ForeignKey('roles.id'), nullable=True)
Reset_Password_logs = db.relationship(
"Resetpasswordlogs", backref=db.backref("User_ResetPasswordLogs"))
Global_Settings = db.relationship(
"Globalsettings", backref=db.backref("User_Globalsettings"))
Login_Histories = db.relationship(
"Loginhistories", backref=db.backref("User_Loginhistories"))
class Post(db.Model):
__tablename__ = "posts"
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.String(255))
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='cascade'))
user = db.relationship('User', foreign_keys=[user_id])
likes_rec = db.relationship('User',
secondary=likes_table,
passive_deletes=True)
all_comment = db.relationship('Post_comment',
back_populates="post",
cascade="all, delete, delete-orphan")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
@property
def num_likes(self):
return len(self.likes_rec)
@property
def num_comments(self):
return len(self.all_comment)
class Message(db.Model):
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
player_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
campaign_id = db.Column(db.Integer,
db.ForeignKey('campaign.id'),
nullable=False)
message = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=func.now())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=func.now(),
onupdate=func.now())
user = db.relationship('User', back_populates="played_campaigns")
campaign = db.relationship('Campaign', back_populates="users")
@classmethod
def create(cls, data, ses, id):
new_message = cls(player_id=ses['userid'],
campaign_id=id,
message=data['message'])
db.session.add(new_message)
db.session.commit()
return new_message
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)
posts = db.relationship('Post', backref='postuser', cascade="all, delete-orphan", lazy=True)
comments = db.relationship('Comments', backref='commentpostuser', cascade="all, delete-orphan", lazy=True)
def ___init__(self, username, email, password):
self.username = username
self.email = email
self.password = password
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
print(app.config['SECRET_KEY'])
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email})'"
class Comment(db.Model):
__tablename__ = "comments"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
blog_id = db.Column(db.Integer, db.ForeignKey('blogs.id'), nullable=False)
blog = db.relationship('Blog', foreign_keys=[blog_id], backref=backref("blog_comments", cascade="all, delete-orphan"))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User', foreign_keys=[user_id], backref=backref("user_comments", cascade="all, delete-orphan"))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
@classmethod
def validate_comment(cls, data):
is_valid = True
if len(data['content']) < 5:
is_valid = False
flash('Comment must be 5 characters long', 'error')
return is_valid
@classmethod
def create_comment(cls, data):
new_comment = Comment(**data)
db.session.add(new_comment)
db.session.commit()
return new_comment
class Referral(db.Model):
id = db.Column(db.Integer, primary_key=True)
dateReferred = db.Column(db.BigInteger, nullable=False)
comment = db.Column(db.Text)
actionTaken = db.Column(db.Text)
isAssessed = db.Column(db.Boolean, nullable=False, default=0)
# FOREIGN KEYS
userId = db.Column(db.Integer, db.ForeignKey("user.id"))
patientId = db.Column(db.String(50), db.ForeignKey("patient.patientId"))
readingId = db.Column(db.String(50), db.ForeignKey("reading.readingId"))
referralHealthFacilityName = db.Column(
db.String(50), db.ForeignKey("healthfacility.healthFacilityName")
)
# RELATIONSHIPS
healthFacility = db.relationship(
"HealthFacility", backref=db.backref("referrals", lazy=True)
)
reading = db.relationship(
"Reading", backref=db.backref("referral", lazy=True, uselist=False)
)
patient = db.relationship("Patient", backref=db.backref("referrals", lazy=True))
@staticmethod
def schema():
return ReferralSchema
