class Students(db.Model):
__tablename__ = "students"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(250))
last_name = db.Column(db.String(250))
age = db.Column(db.Integer)
email = db.Column(db.String(250))
def __init__(self, *args, **kwargs):
self.name = kwargs['name']
self.last_name = kwargs['last_name']
self.age = kwargs['age']
self.email = kwargs['email']
@property
def serializer(self):
return {
'name': self.name,
'last_name': self.last_name,
'age': self.age,
'email': self.email
}
def __str__(self):
return f'{self.name} {self.last_name}'
class Donation(db.Model):
__tablename__ = "donations"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
subscriber_id = db.Column(db.Integer,
db.ForeignKey('subscribers.id'),
nullable=False)
amount = db.Column(db.Integer)
date_of_expiration = db.Column(db.DateTime())
volume_of_blood = db.Column(db.Integer)
onset_time = db.Column(db.DateTime())
termination_time = db.Column(db.DateTime())
torfru = db.Column(db.DateTime())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now())
def _asdict(self):
return {
c.key: getattr(self, c.key)
for c in db.inspect(self).mapper.column_attrs
}
@hybrid_method
def update_donor_dolbd(self):
if self.donor:
self.donor.update_dolbd(self.created_at)
class BlacklistToken(db.Model):
"""
Token Model for storing JWT tokens
"""
__tablename__ = 'blacklist_tokens'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.String(500), unique=True, nullable=False)
blacklisted_on = db.Column(db.DateTime, nullable=False)
def __init__(self, token):
self.token = token
self.blacklisted_on = datetime.datetime.now()
def __repr__(self):
return '<id: token: {}'.format(self.token)
@staticmethod
def check_blacklist(auth_token):
# check whether auth token has been blacklisted
res = BlacklistToken.query.filter_by(token=str(auth_token)).first()
if res:
return True
else:
return False
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
projects = db.relationship('Project', backref='users', lazy=True)
def __init__(self, email, password, admin=False):
self.email = email
self.password = bcrypt.generate_password_hash(
password,
current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8')
self.admin = admin
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<User {0}>'.format(self.email)
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
def __init__(self, email, password, admin=False):
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')
).decode()
self.registered_on = datetime.datetime.now()
self.admin = admin
def encode_auth_token(self, user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp': datetime.datetime.utcnow() + datetime.timedelta(days=0, seconds=5),
'iat': datetime.datetime.utcnow(),
'sub': user_id
}
return jwt.encode(
payload,
app.config.get('SECRET_KEY'),
algorithm='HS256'
)
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
@app.route("/users/index")
def users_index():
users = db.session.query(User).all()
user_list = []
for i in users:
user_list.append(i.email)
return str(user_list)
class Loan(db.Model):
"""Represents the loans that have been accepted."""
__tablename__ = 'loans'
STATES = [
(u'active', u'Active'),
(u'closed', u'Closed'),
]
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
loan_application_id = db.Column(db.Integer,
db.ForeignKey('loan_applications.id'))
loan_application = relationship("LoanApplication", back_populates="loan")
loan_status = db.Column(ChoiceType(STATES), nullable=False)
accepted_on = db.Column(db.DateTime, nullable=False)
requested_amount = db.Column(db.Numeric(12, 4), nullable=False)
def __init__(self, loan_application_id, loan_status, requested_amount):
self.loan_application_id = loan_application_id
self.loan_status = loan_status
self.accepted_on = datetime.datetime.now()
self.requested_amount = requested_amount
def __repr__(self):
return f"{self.loan_application}, accepted_on={self.accepted_on}"
class Attachments(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
fileName = db.Column(db.String(255))
documentLink = db.Column(db.String(500))
answer_id = db.Column(db.Integer,
db.ForeignKey('answer.id'),
nullable=False)
class Section(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
owner_id = db.Column(db.Integer)
assignedTo = db.Column(db.String(255))
assessment_id = db.Column(db.Integer,
db.ForeignKey('assessment.id'),
nullable=False)
class Expert(db.Model):
__tablename__ = 'expert'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
nickname = db.Column(db.String(255), unique=True, nullable=False)
active = db.Column(db.Boolean, default=True)
# def __init__(self, name, created_by):
# self.name = name
# self.created_by = created_by
#
# def save(self):
# db.session.add(self)
# db.session.commit()
#
# @staticmethod
# def get_all(user_id):
# return Expert.query.filter_by(created_by=user_id)
#
# def delete(self):
# db.session.delete(self)
# db.session.commit()
#
# def __repr__(self):
# return "<ExpertList: {}>".format(self.name)
def toDict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class Question(db.Model):
"""
Question Model for storing questions
"""
__tablename__ = 'questions'
Prompt = db.Column(db.String(255), nullable=True)
Choices = db.Column(db.String(255), nullable=True)
Solution = db.Column(db.String(255), nullable=True)
zone = db.Column(db.String(30), nullable=True)
branch = db.Column(db.String(30), nullable=True)
qType = db.Column(db.String(255), nullable=True)
iLink = db.Column(db.String(255), nullable=True)
sLink = db.Column(db.String(255), nullable=True)
blanks = db.Column(db.String(255), nullable=True)
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
__table_args__ = (db.ForeignKeyConstraint([branch, zone],
[Zone.branch, Zone.zone]), {})
def __init__(self, Prompt, Choices, Solution, zone, branch, qType, iLink,
sLink, blanks):
self.Prompt = Prompt
self.Choices = Choices
self.Solution = Solution
self.zone = zone
self.branch = branch
self.qType = qType
self.iLink = iLink
self.sLink = sLink
self.blanks = blanks
class UserModule(db.Model):
__tablename__ = 'user_modules'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
module_id = db.Column(db.Integer(),
db.ForeignKey('modules.id', ondelete='CASCADE'))
class Module(db.Model):
__tablename__ = 'modules'
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
name = db.Column(db.String(50), unique=False)
def __init__(self, name):
self.name = name
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
def __init__(self, email, password, admin=False):
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8')
self.registered_on = datetime.datetime.now()
self.admin = admin
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<User {0}>'.format(self.email)
class Appointment(BaseModel, Base):
""""""
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
date = db.Column(db.DateTime, nullable=False)
notes = db.Column(db.Text, nullable=False)
treatments = db.relationship('Treatment',
secondary='user_symptom_treatment')
class RSAPair(db.Model):
"""
RSAPair model for database mapping to create RSAPair table
which store RSA Key Pairs generated for each of login session
"""
__tablename__ = 'rsa_key'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
public_modulus = db.Column(db.String(), nullable=False)
public_exponent = db.Column(db.Integer, nullable=False)
private_exponent = db.Column(db.String(), nullable=False)
def __init__(self, public_modulus, public_exponent, private_exponent):
"""
RSAPair Model Constructor
:params:
:modulus: public modulus
:exponent: public exponent
:key_mod: private modulus
:returns: void
"""
self.public_modulus = public_modulus
self.public_exponent = public_exponent
self.private_exponent = private_exponent
@staticmethod
def is_existed(key):
"""
Check if provided key is existed
:params: :key: list or RSA instance of the key
:returns: True or False
"""
if isinstance(key, str):
rsa_key = RSAPair.query.filter_by(public_modulus=key).first()
elif isinstance(key, list):
rsa_key = RSAPair.query.filter_by(public_modulus=key[0]).first()
else:
rsa_key = RSAPair.query.filter_by(
public_modulus=str(key.n)).first()
return True if rsa_key else False
@staticmethod
def get_RSA_by_public(public_key):
"""
Get stored RSAPair from the public key
:params: :public_key: the corresponding public key
:returns: :RSAPair:
"""
if isinstance(public_key, list):
return RSAPair.query.filter_by(
public_modulus=public_key[0]).first()
elif isinstance(public_key, str):
return RSAPair.query.filter_by(public_modulus=public_key).first()
elif isinstance(public_key, int):
return RSAPair.query.filter_by(
public_modulus=str(public_key)).first()
else:
return RSAPair.query.filter_by(
public_modulus=str(public_key.n)).first()
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
def __init__(self, email, password, admin=False):
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8')
self.registered_on = datetime.datetime.now()
self.admin = admin
def __str__(self):
return "Email: " + self.email + ", Password: "******"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=0, seconds=5),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload,
app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Validates the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)
if is_blacklisted_token:
return 'Token blacklisted. Please log in again.'
else:
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(255), nullable=False)
price = db.Column(db.Numeric(asdecimal=True, precision=10, scale=2), nullable=False)
bogof = db.Column(db.Boolean, default=False)
class User_Symptom_Treatment(BaseModel, Base):
""""""
__tablename__ = 'user_symptom_treatment'
user_symptom_id = db.Column(db.Integer, db.ForeignKey('user_symptom.id'))
treatment_id = db.Column(db.Integer, db.ForeignKey('treatment.id'))
appointment_id = db.Column(db.Integer, db.ForeignKey('appointment.id'))
date = db.Column(db.DateTime, nullable=False)
notes = db.Column(db.Text, nullable=True)
class Example(db.Model):
__tablename__ = "example"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
field = db.Column(db.String(255), unique=True, nullable=False)
def __init__(self, field):
self.field = field
class User(db.Model):
"""
Defines a user database with associated login information.
This is an SQL table.
"""
# Define the table name, this is the SQLite table name.
__tablename__ = "users"
# Define the column names and their types in this SQL table.
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
def __init__(self, email, password, admin=False):
"""
Calling a new instance of this class runs this __init__
function. This is how a new user is created.
"""
# Assign the values to the class instance, this populates
# the SQL row entries.
self.email = email
# TODO: Comment this, explain what is happening here and
# what is actually saved in the row.
self.password = bcrypt.generate_password_hash(
password,
current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8')
# Save what time the user was created.
self.registered_on = datetime.datetime.now()
# Set the administrator boolean value.
self.admin = admin
def is_authenticated(self):
"""
TODO: Populated this function.
"""
return True
def is_active(self):
return False
def is_anonymous(self):
return False
def get_id(self):
return self.user_id
def __repr__(self):
"""Return a string representation of the user, wrapped in
an HTML User tag."""
return '<User {0}>'.format(self.email)
class Entry(db.Model):
__tablename__ = 'entries'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text)
text = db.Column(db.Text)
def __repr__(self):
return '<Entry id={id} title={title!r}>'.format(id=self.id,
title=self.title)
class WalletMemberRoles(db.Model):
__bind_key__ = 'agwallet'
__tablename__ = 'wallet_member_roles'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
def __init__(self, name):
self.name = name
class Genre(db.Model):
__tablename__ = 'genre'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False, unique=True)
artists = db.relationship('Artist', backref="genre")
def __init__(self, name):
self.name = name
class Skills(db.Model):
"""
Skill fo jobs
"""
__tablename__ = "skills"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), unique=True, nullable=False)
level = db.Column(db.Integer, nullable=True)
class Picture(db.Model):
__tablename__ = 'pictures'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
upload_date = db.Column(db.DateTime, nullable=False)
owner_id = db.Column(db.Integer, nullable=True)
filename = db.Column(db.String(255), unique=True, nullable=False)
filesize = db.Column(db.String(255), nullable=True)
original_filename = db.Column(db.String(255), nullable=True)
original_filesize = db.Column(db.String(255), nullable=True)
geolocation = db.Column(db.String(255), nullable=True)
park_id = db.Column(db.Integer, nullable=True)
tags = db.Column(db.String(255), nullable=True)
def __init__(self, filename, owner_id=None, filesize=None, original_filename=None, \
original_filesize=None, geolocation=None, park_id=None, tags='[]'):
self.upload_date = datetime.datetime.now()
self.owner_id = owner_id
self.filename = filename
self.filesize = filesize
self.original_filename = original_filename
self.original_filesize = original_filesize
self.geolocation = geolocation
self.park_id = park_id
self.tags = tags
def has_tag(self, tag):
return tag in self.tags # string match is enough
def get_tags_list(self):
return json.loads(self.tags)
def get_tags_html(self):
tags_list = self.get_tags_list()
i = 0
html = ''
for tag in tags_list:
if i > 0:
html += ', '
html += '<a href="'
html += app.config.get('BASE_URL') + '/tag/' + tag
html += '">'
html += tag
html += '</a>'
i += 1
return html
def get_details_url(self):
return app.config.get('BASE_URL') + '/image-details/' + str(self.id)
def get_file_url(self):
return app.config.get('BASE_URL') + '/img/' + self.filename
def __repr__(self):
return '<Picture {0}>'.format(self.filename)
class CompanyUsers(db.Model):
__tablename__ = "company_general_users"
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
company_id = db.Column(db.Integer(), nullable=False)
user_id = db.Column(db.Integer(), nullable=False)
def __init__(self, company_id, user_id):
self.company_id = company_id
self.user_id = user_id
class LatexFile(db.Model):
__tablename__ = "latex_files"
uuid = db.Column(db.String(100), primary_key=True)
text = db.Column(db.Text, nullable=False)
def __init__(self, uuid, text):
self.uuid = uuid
self.text = text
class Score(db.Model):
"""
A user's score on a candidate.feature
"""
__tablename__ = 'scores'
user_id = db.Column(pg.UUID, db.ForeignKey('users.id', **fk_cascade), primary_key=True)
candidate_id = db.Column(pg.UUID, db.ForeignKey('candidates.id', **fk_cascade), primary_key=True)
feature_id = db.Column(pg.UUID, db.ForeignKey('features.id', **fk_cascade), primary_key=True)
score = db.Column(db.Integer, nullable=False) # TODO min: 0, max: 5
class User_Symptom(BaseModel, Base):
""""""
__tablename__ = 'user_symptom'
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
symptom_id = db.Column(db.Integer, db.ForeignKey('symptom.id'))
start_date = db.Column(db.DateTime, nullable=False)
end_date = db.Column(db.DateTime, nullable=False)
notes = db.Column(db.Text, nullable=True)
treatments = db.relationship('Treatment',
secondary='user_symptom_treatment')
class Action(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
section_id = db.Column(db.Integer)
owner_id = db.Column(db.Integer)
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=False)
additional_info = db.relationship('AdditionalInformation',
backref='action',
lazy=True)
