class Racer(db.Model):
__tablename__ = 'racers'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
name = db.Column(db.String(255), nullable=False)
city = db.Column(db.String(255))
state = db.Column(db.String(255))
points = db.Column(db.Integer)
cars = db.relationship('Car', secondary=CarRacer, back_populates='racers')
sponsors = db.relationship('Sponsor',
secondary=RacerSponsor,
backref='racers')
laps = db.relationship('BestLap', backref='racer')
created_date = db.Column(db.DateTime,
default=datetime.datetime.utcnow(),
nullable=False)
updated_date = db.Column(db.DateTime, nullable=True)
#Picture
def __init__(self, email, name, city, state, points):
self.email = email
self.name = name
self.city = city
self.state = state
self.points = points
self.created_date = datetime.datetime.now()
def __repr__(self):
return '<Racer {0}>'.format(self.name)
class Document(db.Model):
"""
Document upload by user to extract skill
"""
__tablename__ = "documents"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content_type = db.Column(db.String(255), nullable=False)
title = db.Column(db.String(1000), nullable=False)
created_on = db.Column(db.DateTime, nullable=False)
created_by = db.Column(db.Integer, nullable=True) # User.id
filename = db.Column(db.String(1000), nullable=True)
path = db.Column(db.String(1255), nullable=True)
def __init__(self, content_type, title, created_by, filename, path):
self.content_type = content_type
self.title = title
self.created_on = datetime.datetime.now()
self.created_by = created_by
self.filename = filename
self.path = path
def get_id(self):
return self.id
def __repr__(self):
return "<Document {0}>".format(self.title)
def set_content(self, content):
self.content = content
def get_content(self):
return self.content
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 Product(db.Model):
__tablename__ = "products"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
permalink = db.Column(db.String(255), nullable=False)
date_created_gmt = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
description = db.Column(db.String(255), nullable=False)
price = db.Column(db.Float, nullable=False)
weight = db.Column(db.Float, nullable=False)
def __init__(self, name, permalink, description, price, weight):
self.name = name
self.permalink = permalink
self.description = description
self.price = price
self.weight = weight
def get_id(self):
return self.id
def __repr__(self):
return "<Product {0}>".format(self.name)
class Projects(db.Model):
__tablename__ = 'projects'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
proj_id = db.Column(db.String(10), nullable=False)
proj_name = db.Column(db.String(255), nullable=False)
proj_desc = db.Column(db.String(9999), nullable=False)
proj_status = db.Column(db.String(25), nullable=False)
created_by = db.Column(db.Integer, nullable=False)
modified_by = db.Column(db.Integer, nullable=True)
created_date = db.Column(db.DateTime, nullable=False)
modified_date = db.Column(db.DateTime, nullable=True)
actions = db.relationship('Assessment', backref='projects', lazy=True)
def __init__(self, proj_id, proj_name, proj_desc, proj_status, created_by):
self.proj_id = proj_id
self.proj_name = proj_name
self.proj_desc = proj_desc
self.proj_status = proj_status
self.created_by = created_by
self.created_date = datetime.datetime.now()
def __repr__(self):
return '<Projects %r>' % (self.proj_name)
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class Song(db.Model):
__tablename__ = "songs"
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(255), nullable=False)
artist = db.Column(db.String(255), nullable=False)
album = db.Column(db.String(255), nullable=False)
song_url = db.Column(db.String(255), nullable=False)
# artist_id = Column(Integer, ForeignKey(Artist.id), primary_key=True)
# artist = relationship('Artist', foreign_keys='Song.artist_id')
#
# album_id = Column(Integer, ForeignKey(Album.id), primary_key=True)
# album = relationship('Album', foreign_keys='Song.album_id')
def __init__(self, title, artist, album, song=None, song_url=None):
self.created_at = datetime.datetime.now()
self.title = title
self.artist = artist
self.album = album
self.song_url = "songs/%s.mp3" % str(
uuid.uuid4()) if song else song_url
if song:
song.save(os.path.join(app.static_folder, self.song_url))
def response(self):
return
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 Course(db.Model):
__tablename__ = 'courses'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), unique=True, nullable=False)
description = db.Column(db.Text(), nullable=False)
subject = db.Column(db.String(255), nullable=False)
start_date = db.Column(db.DateTime, nullable=False)
end_date = db.Column(db.DateTime, nullable=False)
active = db.Column(db.Boolean, nullable=False, default=True)
teacher_id = db.Column(db.Integer,
db.ForeignKey('teachers.id'),
nullable=False)
teacher = db.relationship('Teacher', backref='courses')
students = db.relationship('Student',
secondary=course_student_association_table,
backref='courses')
def __init__(self, name, description, subject, start_date, end_date,
teacher_id):
self.name = name
self.description = description
self.subject = subject
self.start_date = start_date
self.end_date = end_date
self.teacher_id = teacher_id
def __repr__(self):
return '<Class {0}>'.format(self.name)
class UserPost(db.Model):
""" User Post Model for storing posts made by users """
__tablename__ = "user_posts"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
title = db.Column(db.String(255), unique=False, nullable=False)
body = db.Column(db.String(2000), nullable=True)
link = db.Column(db.String(1000), nullable=True)
image = db.Column(db.String(1000), nullable=True)
created_on = db.Column(db.DateTime, nullable=False, index=True)
visibility = db.Column(db.Boolean, nullable=False, default=True)
delete_flag = db.Column(db.Boolean, nullable=False, default=False)
def __init__(self,
title="Empty Post Title",
body="empty post body",
link="",
image="",
visibility=True,
delete_flag=False,
user_id=None,
**kwargs):
self.user_id = user_id
self.title = title
self.body = body
self.link = link
self.image = image
self.created_on = datetime.datetime.now()
self.visibility = visibility
self.delete_flag = delete_flag
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 SARResponse(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
sarattachment = db.relationship('sar_attachment',
lazy='dynamic',
cascade='all,delete',
backref=db.backref('sarresponse',
lazy='joined'))
sar_id = db.Column(db.Integer, db.ForeignKey('sar.id'), nullable=False)
fromUser = db.Column(db.String(255))
toUser = db.Column(db.String(255))
responseText = db.Column(db.String(255))
user_id = db.Column(db.Integer)
user_name = db.Column(db.String(255))
def __init__(self, data, sar_id=None):
self.fromUser = data['fromUser']
self.toUser = data['toUser']
self.responseText = data['responseText']
# self.user_name = data['user_name']
# self.user_id = data['user_id']
self.sar_id = sar_id
#
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
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 Secuencia(db.Model):
__tablename__ = 'secuencias'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
customer_id = db.Column(db.Integer, db.ForeignKey('customers.id'), nullable=False)
radar_id = db.Column(db.Integer, db.ForeignKey('radares.id'), nullable=False) # ID de radar
web_path = db.Column(db.String(255), unique=True, nullable=False)
fs_path = db.Column(db.String(255), unique=True, nullable=False)
vel_max = db.Column(db.Integer, nullable=False)
vel = db.Column(db.Integer, nullable=False)
secuencia = db.Column(db.String(255), unique=True, nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
processed = db.Column(db.Boolean, nullable=False, default=False)
reprocess = db.Column(db.Boolean, nullable=False, default=False)
def __init__(self, customer_id,radar_id,web_path,fs_path,vel_max,vel,secuencia,registered_on,processed=False,reprocess=False):
self.customer_id = customer_id
self.radar_id = radar_id
self.web_path = web_path
self.fs_path = fs_path
self.vel_max = vel_max
self.vel = vel
self.secuencia = secuencia
self.registered_on = registered_on # datetime.datetime.now()
self.processed = processed
self.reprocess = reprocess
def get_id(self):
return self.id
def __repr__(self):
return '<Secuencia {0}>'.format(self.web_path)
class Section(db.Model):
__tablename__ = 'section'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
owner_id = db.Column(db.Integer, nullable=False)
parentSectionId = db.Column(db.Integer, nullable=True)
assessment_id = db.Column(db.Integer,
db.ForeignKey('assessment.id'),
nullable=False)
created_date = db.Column(db.DateTime, nullable=False)
modified_date = db.Column(db.DateTime, nullable=True)
status = db.Column(db.String(255), nullable=True)
quesRelation = db.relationship('Question', backref='section', lazy=True)
sectionsdpi = db.relationship('DpiAudit', backref='section', lazy=True)
def __init__(self, name, owner_id, parentSectionId, assessment_id):
self.name = name
self.owner_id = owner_id
self.parentSectionId = parentSectionId
self.assessment_id = assessment_id
self.created_date = datetime.datetime.now()
def __repr__(self):
return '<Section %r>' % (self.name)
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class Attachments(db.Model):
__tablename__ = 'attachments'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
fileName = db.Column(db.String(255), nullable=False)
documentLink = db.Column(db.String(255), nullable=False)
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=False)
created_date = db.Column(db.DateTime, nullable=False)
modified_date = db.Column(db.DateTime, nullable=True)
def __init__(self, fileName, documentLink, question_id):
self.fileName = fileName
self.documentLink = documentLink
self.question_id = question_id
self.created_date = datetime.datetime.now()
def __repr__(self):
return '<Attachments %r>' % (self.fileName)
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class DpiAudit(db.Model):
__tablename__ = 'Dpiaudit'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=False)
section_id = db.Column(db.Integer,
db.ForeignKey('section.id'),
nullable=False)
description = db.Column(db.String(255), nullable=False)
owner_id = db.Column(db.String(255), nullable=False)
created_date = db.Column(db.DateTime, nullable=False)
modified_date = db.Column(db.DateTime, nullable=True)
def __init__(self, question_id, section_id, owner_id, description):
self.question_id = question_id
self.section_id = section_id
self.owner_id = owner_id
self.description = description
self.created_date = datetime.datetime.now()
def __repr__(self):
return '<Action %r>' % (self.owner_id)
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class Entry(db.Model):
"""
Entry model for storing selected user text
"""
__tablename__ = 'entries'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
text = db.Column(db.Text, nullable=False)
created_on = db.Column(db.DateTime, nullable=False)
keywords = db.Column(db.String(500), nullable=True)
url = db.Column(db.String(500), nullable=False)
title = db.Column(db.String(500), nullable=False)
def __init__(self,
user_id,
text,
url,
title,
created_on=None,
keywords=None):
self.user_id = user_id
self.text = text
self.url = url
self.title = title
self.created_on = datetime.datetime.now(
) if not created_on else created_on
self.keywords = keywords
class Answer(db.Model):
__tablename__ = 'answer'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=False)
section_id = db.Column(db.Integer,
db.ForeignKey('section.id'),
nullable=False)
answer_sel = db.Column(db.String(255), nullable=True)
comments = db.Column(db.String(255), nullable=False)
created_date = db.Column(db.DateTime, nullable=False)
modified_date = db.Column(db.DateTime, nullable=True)
# attachment = db.relationship('Attachments', backref='answer', lazy=True)
def __init__(self, question_id, section_id, answer_sel, comments):
self.question_id = question_id
self.section_id = section_id
self.answer_sel = answer_sel
self.comments = comments
self.created_date = datetime.datetime.now()
def __repr__(self):
return '<Answer %r>' % (self.comments)
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "user_auth"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(200), nullable=False)
user_role = db.Column(db.String(100), nullable=False)
verified = db.Column(db.String(100), nullable=True)
created_on = db.Column(db.DateTime, nullable=False)
modified_on = db.Column(db.DateTime, nullable=False)
def __init__(self, email, password, user_role):
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')).decode()
self.created_on = datetime.datetime.now()
self.modified_on = datetime.datetime.now()
self.user_role = user_role
self.verified = 'NotVerified'
def encode_auth_token(self, user_email):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=1, seconds=0),
'iat':
datetime.datetime.utcnow(),
'sub':
user_email
}
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 str(payload['sub'])
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Radar(db.Model):
__tablename__ = 'radares'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
customer_id = db.Column(db.Integer, db.ForeignKey('customers.id'), nullable=False)
pub_id = db.Column(db.String(50), unique=True, nullable=False) # ID de radar para Evial/barrio
configuration = db.Column(db.String(2048), unique=False, nullable=True)
registered_on = db.Column(db.DateTime, nullable=False)
online = db.Column(db.Boolean, nullable=False, default=False)
conn_port = db.Column(db.String(3), unique=False, nullable=True)
def __init__(self, customer_id,pub_id,configuration,registered_on,online,conn_port='000'):
self.customer_id = customer_id
self.pub_id = pub_id
self.configuration = configuration
self.registered_on = registered_on # datetime.datetime.now()
self.online = online
self.conn_port = conn_port
def get_id(self):
return self.id
def __repr__(self):
return '<Radar {0}>'.format(self.pub_id)
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(1000), nullable=False)
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)
entries = db.relationship('Entry', backref='user', lazy='dynamic')
def __init__(self, name, email, password, admin=False):
self.name = name
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:
days, hours, seconds = app.config.get('TOKEN_EXPIRATION')
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=days, hours=hours, seconds=seconds),
'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 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 ActionNote(db.Model):
__tablename__ = 'action_note'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=False)
owner_id = db.Column(db.Integer, nullable=False)
type = db.Column(db.String(255), nullable=False)
notes = db.Column(db.String(999), nullable=False)
created_date = db.Column(db.DateTime, nullable=False)
modified_date = db.Column(db.DateTime, nullable=True)
def __init__(self, data):
self.question_id = data['question_id']
self.owner_id = data['owner_id']
self.type = data['type']
self.notes = data['notes']
self.created_date = datetime.datetime.now()
def __repr__(self):
return '<ActionNote %r>' % (self.owner_id)
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class LoanApplication(db.Model):
"""Model for storing the loan applications of the users."""
__tablename__ = 'loan_applications'
STATES = [
(u'pending', u'Pending'),
(u'approved', u'Approved'),
(u'denied', u'Denied'),
]
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
creator = relationship("User", back_populates="loan_applications")
business_name = db.Column(db.String(255), nullable=False)
tax_id = db.Column(db.String(20), nullable=False)
requested_amount = db.Column(db.Numeric(12, 4), nullable=False)
application_status = db.Column(ChoiceType(STATES), nullable=False)
requested_on = db.Column(db.DateTime, nullable=False)
loan = relationship("Loan",
uselist=False,
back_populates="loan_application")
def __init__(self, creator_id, business_name, requested_amount, tax_id,
application_status):
self.creator_id = creator_id
self.business_name = business_name
self.requested_amount = requested_amount
self.tax_id = tax_id
self.application_status = application_status
self.requested_on = datetime.datetime.now()
def __repr__(self):
return f"{self.business_name}, {self.requested_amount}, {self.application_status}"
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:
# exp: expiration date of the token
# iat: time the token is generated
# sub: subject of the token (user that it identifies)
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=0, seconds=60),
'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 # static because it doesn't relate to the classes instance
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 login again.'
else:
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please login again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please login again.'
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):
"""
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 AdditionalInformation(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type = db.Column(db.String(255))
requester = db.Column(db.String(255))
responder = db.Column(db.String(255))
request_date = db.Column(db.DateTime, default=datetime.datetime.now())
action_id = db.Column(db.Integer,
db.ForeignKey('action.id'),
nullable=False)
class Sar(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
assignedTo = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False)
otherInfo = db.Column(db.String(255))
sarDescription = db.Column(db.String(255))
externalUser = db.Column(db.String(255))
representative = db.Column(db.String(255))
user_confirmed = db.Column(db.String(255))
rep_confirmed = db.Column(db.String(255))
priority = db.Column(db.String(255))
completionTime = db.Column(db.DateTime)
#completionTime = db.Column(db.String(255))
status = db.Column(db.String(255))
ticketinfo = db.relationship('TicketInfo',
lazy='dynamic',
backref=db.backref('sar', lazy='joined'))
ticket = db.relationship('Ticket',
lazy='dynamic',
cascade='all,delete',
innerjoin=True,
primaryjoin="Sar.id == Ticket.sar_id",
backref=db.backref('sar', lazy='joined'))
sar_response = db.relationship('SARResponse',
lazy='dynamic',
cascade='all,delete',
backref=db.backref('sar', lazy='joined'))
user_id = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False)
creation_time = db.Column(db.DateTime, nullable=False)
modification_time = db.Column(db.DateTime, default=datetime.datetime.now())
created_by = db.Column(db.String(255))
modified_by = db.Column(db.String(255))
isEscalated = db.Column(db.Boolean)
assigned_user = db.relationship('Users', foreign_keys='Sar.assignedTo')
created_user = db.relationship('Users', foreign_keys='Sar.user_id')
def __init__(self, data, user_id=None):
self.assignedTo = data['assignedTo']
self.otherInfo = data['otherInfo']
self.sarDescription = data['sarDescription']
self.externalUser = data['externalUser']
self.representative = data['representative']
self.completionTime = datetime.datetime.now()
self.status = data['status']
self.creation_time = datetime.datetime.now()
# self.modification_time = data["modification_time"]
self.created_by = data["created_by"]
self.modified_by = data["modified_by"]
self.isEscalated = data['isEscalated']
self.priority = data['priority']
self.user_id = data['user_id']
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
