class ClientDepartmentsDetailsRepo(Base):
__tablename__ = 'client_department_details_m'
department_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.client_id))
_function = db.Column(db.String(20), nullable=False)
role = db.Column(db.String(20), nullable=False)
location = db.Column(db.String(20), nullable=False)
band = db.Column(db.String(10), nullable=False)
EmployeeDetailsRepo = relationship("EmployeeDetailsRepo",
cascade="all,delete",
backref="ClientDepartmentsDetailsRepo",
lazy='joined')
def __repr__(self):
return "<ClientDepartmentsDetailsRepo(department_id='{}',cycle_id='{}',_function='{}',role='{}',location='{}'," \
"band='{}')>".format(self.department_id, self.cycle_id, self._function, self.role, self.location,
self.band)
def get_json(self):
body = {
"department_id": self.department_id,
"cycle_id": self.cycle_id,
"function": self._function,
"role": self.role,
"location": self.location,
"band": self.band
}
return body
class Superuser(BaseModel):
__tablename__ = 'superusers'
email = db.Column(db.String(255), nullable=False, unique=True)
password_hash = db.Column(db.String(255), nullable=False)
fullname = db.Column(db.String(255), nullable=True)
last_login_at = db.Column(db.DateTime, nullable=True)
activities = db.relationship('Activity',
backref='superuser',
cascade='all, delete-orphan')
@property
def password(self):
raise AttributeError('password is not a readable attribue')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def is_authenticated(self):
return True
class UserTagTable(db.Model):
""" Initialize the user_tag_table from MySQL database
+----------------+---------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------------+---------------+------+-----+---------+----------------+
| userID | int(11) | NO | | NULL | |
| itemID | int(11) | NO | PRI | NULL | auto_increment |
| Link | varchar(1000) | YES | | NULL | |
| CreateTime | datetime | NO | | NULL | |
| Tag | varchar(1000) | YES | | NULL | |
| Title | varchar(1000) | YES | | NULL | |
| LastUpdateTime | datetime | NO | | NULL | |
+----------------+---------------+------+-----+---------+----------------+
"""
userID = db.Column(db.Integer,
unique=False,
nullable=False,
primary_key=False)
itemID = db.Column(db.Integer,
unique=True,
nullable=False,
primary_key=True)
Link = db.Column(db.String(1000))
Tag = db.Column(db.String(1000))
Title = db.Column(db.String(1000))
CreateTime = db.Column(db.DateTime)
LastUpdateTime = db.Column(db.DateTime)
class ClientRepo(Base):
__tablename__ = 'client_table_m'
client_id = db.Column(db.String(64), primary_key=True)
client_name = db.Column(db.String(64), nullable=False)
client_email_id = db.Column(db.String(64), nullable=False, unique=True)
client_uri = db.Column(db.String(64))
cycle = relationship("ClientCycleRepo",
backref='clientrepo',
cascade="all,delete",
lazy='dynamic')
employee = relationship("EmployeeDetailsRepo",
backref='clientrepo',
cascade="all,delete",
lazy='dynamic')
ClientAdminRepo = relationship("ClientAdminRepo",
backref='clientrepo',
cascade="all,delete",
lazy='dynamic')
def __repr__(self):
return "<Clients(client_id='{}',client_name='{}',client_email_id='{}',client_uri='{}')>".format(
self.client_id, self.client_name, self.client_email_id,
self.client_uri)
def get_json(self):
body = {
"client_id": self.client_id,
"client_name": self.client_name,
"client_email_id": self.client_email_id,
"client_uri": self.client_uri
}
return body
class EmployeRelationMapping(Base):
__tablename__ = 'employee_relation_mapping_t'
map_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cycle_id = db.Column(db.Integer,
db.ForeignKey(ClientCycleRepo.cycle_id),
nullable=False)
pat_emp_id = db.Column(db.String(20), nullable=False)
relation_id = db.Column(db.Integer,
db.ForeignKey(UserRelationRepo.relation_id),
nullable=False)
target_emp_id = db.Column(db.String(20), nullable=False)
AssessmentTestAnswers = relationship("AssessmentTestAnswers",
cascade="all,delete",
backref="EmployeRelationMapping",
lazy='joined')
FeedBackStatements = relationship("FeedBackStatements",
cascade="all,delete",
backref="EmployeRelationMapping",
lazy='joined')
def __repr__(self):
return "<EmployeRelationMapping(map_id='{}',cycle_id='{}',pat_emp_id='{}',relation_id='{}'," \
"target_emp_id='{}')>".format(self.map_id, self.cycle_id, self.pat_emp_id, self.relation_id, self.target_emp_id)
def get_json(self):
body = {
"map_id": self.map_id,
"cycle_id": self.cycle_id,
"pat_emp_id": self.pat_emp_id,
"relation_id": self.relation_id,
"target_emp_id": self.target_emp_id
}
return body
class Activity(BaseModel):
__tablename__ = 'activities'
channel = db.Column(db.String(255), nullable=True)
description = db.Column(db.String(255), nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
superuser_id = db.Column(
db.Integer, db.ForeignKey('superusers.id', ondelete='CASCADE'))
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
uname = db.Column(db.String(80), unique=True)
password_hash = db.Column(db.String(80))
email = db.Column(db.String(80), unique=True)
phone = db.Column(db.String(20), unique=True)
img = db.Column(db.String(80))
title = db.Column(db.Integer)
confirmed = db.Column(db.Boolean, nullable=False, default=False)
confirmed_on = db.Column(db.DateTime, nullable=True)
def __init__(self,
uname,
password,
email,
phone=None,
img=None,
title=None,
confirmed=False,
confirmed_on=None):
self.uname = uname
self.password_hash = generate_password_hash(password)
self.email = email
self.phone = phone
self.img = img
self.title = title
self.confirmed = confirmed
self.confirmed_on = confirmed_on
def serialize(self):
return {
"id": self.id,
"uname": self.uname,
"password": self.password_hash,
"role": self.title,
"email": self.email,
"phone": self.phone,
"img": self.img,
"title": self.title,
"confirmed": self.confirmed,
"confirmed_on": self.confirmed_on
}
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def get_user_by_id(id):
return User.query.filter_by(id=id).first()
def is_tourist(email):
if UserModule.query.filter(email=email).count() > 0:
return False
return True
class ClientCycleRepo(Base):
__tablename__ = 'client_cycle_details_m'
cycle_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
client_id = db.Column(db.String(64),
db.ForeignKey(ClientRepo.client_id),
nullable=False)
cycle_name = db.Column(db.String(64), nullable=False)
created_date = db.Column(db.Date, nullable=False)
from_date = db.Column(db.Date)
to_date = db.Column(db.Date)
is_active = db.Column(db.Boolean, default=True)
departments = relationship("ClientDepartmentsDetailsRepo",
cascade="all,delete",
backref="clientcyclerepo",
lazy='dynamic')
EmployeRelationMapping = relationship("EmployeRelationMapping",
cascade="all,delete",
backref="clientcyclerepo",
lazy='dynamic')
ParticipantsAssessmentStatus = relationship("ParticipantsAssessmentStatus",
cascade="all,delete",
backref="clientcyclerepo",
lazy='dynamic')
IndividualScores = relationship("IndividualScores",
cascade="all,delete",
backref="clientcyclerepo",
lazy='dynamic')
CompetancyScores = relationship("CompetancyScores",
cascade="all,delete",
backref="clientcyclerepo",
lazy='dynamic')
ClientAdminRepo = relationship("ClientAdminRepo",
cascade="all,delete",
backref="clientcyclerepo",
lazy='dynamic')
def __repr__(self):
return "<ClientCycleRepo(cycle_id='{}',client_id='{}',cycle_name='{}',from_date='{}',to_date='{}'," \
"is_active='{}')>".format(self.cycle_id, self.client_id, self.cycle_name, self.from_date, self.to_date,
self.is_active)
def get_json(self):
body = {
"cycle_id": self.cycle_id,
"client_id": self.client_id,
"cycle_name": self.cycle_name,
"created_date": self.created_date,
"from_date": self.from_date,
"to_date": self.to_date,
"is_active": self.is_active,
}
return body
class User(BaseModel):
__tablename__ = 'users'
fullname = db.Column(db.String(255), nullable=False)
dob = db.Column(db.String(255), nullable=False)
home_address = db.Column(db.String(255), nullable=True)
work_address = db.Column(db.String(255), nullable=True)
phone_number = db.Column(db.String(255), nullable=False)
password_hash = db.Column(db.String(255), nullable=False)
occupation = db.Column(db.String(255), nullable=True)
status = db.Column(db.String(255), nullable=True)
last_login_at = db.Column(db.DateTime, nullable=True)
last_logout_at = db.Column(db.DateTime, nullable=True)
activities = db.relationship('Activity',
backref='user',
cascade='all, delete-orphan')
@property
def password(self):
raise AttributeError('password is not a readable attribue')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def is_anonymous(self):
return False
def get_id(self):
return self.id
class House(db.Model):
house_id = db.Column(db.Integer, primary_key=True)
house_keeper = db.Column(db.Integer)
year = db.Column(db.Integer)
color = db.Column(db.String)
house_name = db.Column(db.String(30))
def __init__(self, house_keeper, year, color, house_name):
self.house_keeper = house_keeper
self.year = year
self.color = color
self.house_name = house_name
def get_houselist_by_year(year):
houseList = House.query.filter_by(year=year).all()
return houseList
def get_house_by_id(house_id):
house = House.query.filter_by(house_id=house_id).first()
return house
def get_house_by_housekeeper(hkid):
house = House.query.filter_by(house_keeper=hkid).first()
return house
def serialize(self):
return {
"house_id": self.house_id,
"house_keeper": self.house_keeper,
"year": self.year,
"color": self.color,
"house_name": self.house_name
}
class CompetancyScores(Base):
__tablename__ = 'competancy_question_answer_score_t'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.cycle_id))
emp_id = db.Column(db.String(20),
db.ForeignKey(EmployeeDetailsRepo.emp_id))
competency_id = db.Column(db.Integer,
db.ForeignKey(CompetencyTypeRepo.competency_id))
avg_self_score = db.Column(db.DECIMAL(4, 2))
avg_senior_score = db.Column(db.DECIMAL(4, 2))
avg_peer_score = db.Column(db.DECIMAL(4, 2))
avg_subordinates_score = db.Column(db.DECIMAL(4, 2))
avg_others_score = db.Column(db.DECIMAL(4, 2))
avg_respondants_score = db.Column(db.DECIMAL(4, 2))
gap_analysis_score = db.Column(db.DECIMAL(6, 2))
def __repr__(self):
return "<CompetancyScores(id='{}')>".format(self.id)
def get_json(self):
body = {
"id": self.id,
"cycle_id": self.cycle_id,
"emp_id": self.emp_id,
"competency_id": self.competency_id,
"avg_self_score": self.avg_self_score,
"avg_senior_score": self.avg_senior_score,
"avg_peer_score": self.avg_peer_score,
"avg_subordinates_score": self.avg_subordinates_score,
"avg_others_score": self.avg_others_score,
"avg_respondants_score": self.avg_respondants_score,
"gap_analysis_score": self.gap_analysis_score
}
return body
class IndividualScores(Base):
__tablename__ = 'individual_question_answer_score_t'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.cycle_id))
emp_id = db.Column(db.String(20),
db.ForeignKey(EmployeeDetailsRepo.emp_id))
que_id = db.Column(db.Integer,
db.ForeignKey(AssessmentQuestionsRepo.que_id))
self_score = db.Column(db.Integer)
avg_senior_score = db.Column(db.DECIMAL(4, 2))
avg_peer_score = db.Column(db.DECIMAL(4, 2))
avg_subordinates_score = db.Column(db.DECIMAL(4, 2))
avg_respondants_score = db.Column(db.DECIMAL(4, 2))
def __repr__(self):
return "<IndividualScores(id='{}')>".format(self.id)
def get_json(self):
body = {
"id": self.id,
"cycle_id": self.cycle_id,
"emp_id": self.emp_id,
"que_id": self.que_id,
"self_score": self.self_score,
"avg_senior_score": self.avg_senior_score,
"avg_peer_score": self.avg_peer_score,
"avg_subordinates_score": self.avg_subordinates_score,
"avg_others_score": self.avg_others_score,
"avg_respondants_score": self.avg_respondants_score
}
return body
class ParticipantsAssessmentStatus(Base):
__tablename__ = 'participant_ass_status_t'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
emp_id = db.Column(db.String(20),
db.ForeignKey(EmployeeDetailsRepo.emp_id))
cycle_id = db.Column(db.Integer, db.ForeignKey(ClientCycleRepo.cycle_id))
is_respondant_selective = db.Column(db.Boolean, default=False)
is_block_report = db.Column(db.Boolean, default=False)
total_respondant_count = db.Column(db.Integer)
seniors_count = db.Column(db.Integer)
subordinates_count = db.Column(db.Integer)
peer_count = db.Column(db.Integer)
others_count = db.Column(db.Integer)
ass_com_seniors_count = db.Column(db.Integer, default=0)
ass_com_subordinates_count = db.Column(db.Integer, default=0)
ass_com_peer_count = db.Column(db.Integer, default=0)
ass_com_others_count = db.Column(db.Integer, default=0)
ass_com_respondant_count = db.Column(db.Integer, default=0)
completion_status_id = db.Column(
db.Integer,
db.ForeignKey(AssessmentCompletionStatusRepo.status_id),
default=1)
is_generate_report = db.Column(db.Boolean, default=False)
def __repr__(self):
return "<ParticipantsAssessmentStatus(id='{}')>".format(self.id)
class ClientAdminRepo(Base):
__tablename__ = 'client_admin_details_m'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cycle_id = db.Column(db.Integer, db.ForeignKey(ClientRepo.client_id))
client_id = db.Column(db.Integer,
db.ForeignKey(ClientCycleRepo.client_id),
nullable=False)
emp_id = db.Column(db.String(64),
db.ForeignKey(EmployeeDetailsRepo.emp_id),
nullable=False)
password_ = db.Column(db.Text)
is_super_admin = db.Column(db.Boolean, default=True)
def __repr__(self):
return "<ClientAdminRepo(cycle_id='{}',client_id='{}',emp_id='{}',password_='{}'," \
"is_super_admin='{}')>".format(self.cycle_id, self.client_id, self.emp_id, self.password_,
self.is_super_admin)
def get_json(self):
body = {
"cycle_id": self.cycle_id,
"client_id": self.client_id,
"emp_id": self.emp_id,
"password": self.password_,
"is_super_admin": self.is_super_admin
}
return body
class Customer(STModel):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(NAME_LENGTH), index=True, nullable=False)
contact = db.Column(db.String(CONTACT_LENGTH))
address = db.Column(db.String(ADDRESS_LENGTH))
sale_transactions = db.relationship('SaleTransaction',
backref='customer',
lazy='dynamic',
cascade='save-update, merge, delete')
@classmethod
def check_exist(cls, name):
return db.session.query(exists().where(Customer.name == name)).scalar()
@classmethod
def try_add(cls, name, contact=None, address=None):
# no need to check exists in here because
# the form has handled it and the model fields has unique=True
new_cou = Customer(name=name, contact=contact, address=address)
try:
db.session.add(new_cou)
db.session.commit()
return True
except Exception as e:
cls.add_error(e)
db.session.rollback()
return False
@classmethod
def get_list(cls,
page_num=DEFAULT_PAGE_NUMBER,
list_per_page=DEFAULT_POSTS_PER_PAGE,
include_header=True,
order_by=None,
**kwargs):
q = Customer.query.with_entities(Customer.id, Customer.name,
Customer.address, Customer.contact)
q = paginate_query(q, page_num, list_per_page)
if order_by:
q = q.order_by(order_by)
c_list = q.all()
if include_header:
c_list.insert(0, tuple(x['name'] for x in q.column_descriptions))
return c_list
class EmployeeDetailsRepo(Base):
__tablename__ = 'employee_details_m'
emp_id = db.Column(db.String(20), primary_key=True)
client_id = db.Column(db.String(64),
db.ForeignKey(ClientRepo.client_id),
nullable=False)
emp_name = db.Column(db.String(64), nullable=False)
emp_email = db.Column(db.String(64), nullable=False)
department_id = db.Column(db.Integer,
db.ForeignKey(
ClientDepartmentsDetailsRepo.department_id),
nullable=False)
role_id = db.Column(db.Integer,
db.ForeignKey(UserRoleRepo.role_id),
nullable=False)
password = db.Column(db.Text, nullable=False)
ParticipantsAssessmentStatus = relationship("ParticipantsAssessmentStatus",
cascade="all,delete",
backref="EmployeeDetailsRepo")
IndividualScores = relationship("IndividualScores",
cascade="all,delete",
backref="EmployeeDetailsRepo")
CompetancyScores = relationship("CompetancyScores",
cascade="all,delete",
backref="EmployeeDetailsRepo")
ClientAdminRepo = relationship("ClientAdminRepo",
cascade="all,delete",
backref="EmployeeDetailsRepo")
def __repr__(self):
return "<EmployeeDetailsRepo(emp_id='{}',client_id='{}',emp_name='{}',emp_email='{}')>".format(
self.emp_id, self.client_id, self.emp_name, self.emp_email)
def get_json(self):
body = {
"emp_id": self.emp_id,
"client_id": self.client_id,
"emp_name": self.emp_name,
"emp_email": self.emp_email,
"department_id": self.department_id,
"role_id": self.role_id
}
return body
class domain(db.Model):
__tablename__ = 'domain'
domainID = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
name = db.Column(db.String(30), nullable=False)
# This function should return a printable representation of the domain object
def __repr__(self):
return '<domain: {}>'.format(self.name)
class topic(db.Model):
__tablename__ = 'topic'
topicID = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
name = db.Column(db.String(30), nullable=False)
domainID = db.Column(db.Integer, db.ForeignKey('domain.domainID'), nullable=False)
# This function should return a printable representation of the topic object
def __repr__(self):
return '<topic: {}>'.format(self.name)
class option(db.Model):
__tablename__ = 'option'
optionID = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
description = db.Column(db.String(255), nullable=False)
correct = db.Column(db.SmallInteger, nullable=False)
questionID = db.Column(db.Integer, db.ForeignKey('question.questionID'), nullable=False)
# This function should return a printable representation of the option object
def __repr__(self):
return '<option: {}>'.format(self.description)
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(40), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
activated = db.Column(db.Boolean, default=False)
sheets = db.relationship('Character', backref='owner', lazy=True)
def get_token(self, expires=600):
s = Serializer(app.config['SECRET_KEY'], expires)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except Exception:
return None
return User.query.get(user_id)
class AutoComplete(db.Model):
"""Declare model for "auto_complete" database.
+----------------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------------+---------------+------+-----+---------+-------+
| starting_words | varchar(3000) | YES | | NULL | |
| following_word | varchar(3000) | YES | | NULL | |
| word_count | int(11) | YES | | NULL | |
+----------------+---------------+------+-----+---------+-------+
Args:
db (flask_sqlalchemy.model.DefaultMeta): base class of model
"""
starting_words = db.Column(db.String(3000))
following_word = db.Column(db.String(3000))
word_count = db.Column(db.Integer,
unique=False,
nullable=True,
primary_key=True)
class user(db.Model):
__tablename__ = 'user'
userID = db.Column(db.Integer, nullable=False, primary_key=True)
name = db.Column(db.String(255), nullable=False)
# 28/03/2021 - create relationship between 'user' and 'user_test'
testsTaken = db.relationship('user_test', backref='user', lazy='joined')
# This function should return a printable representation of the user object
def __repr__(self):
return '<user: {}>'.format(self.name)
class Supplier(STModel):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(NAME_LENGTH), index=True, nullable=False)
contact = db.Column(db.String(CONTACT_LENGTH))
address = db.Column(db.String(ADDRESS_LENGTH))
purchase_transactions = db.relationship(
'PurchaseTransaction',
backref='supplier',
lazy='dynamic',
cascade='save-update, merge, delete')
@classmethod
def get_list(cls,
page_num=DEFAULT_PAGE_NUMBER,
list_per_page=DEFAULT_POSTS_PER_PAGE,
include_header=True,
order_by=None,
**kwargs):
q = Supplier.query.with_entities(Supplier.id, Supplier.name,
Supplier.contact, Supplier.address)
q = paginate_query(q, page_num, list_per_page)
s_list = q.all()
s_list.insert(0, tuple(x['name'] for x in q.column_descriptions))
return s_list
@classmethod
def try_add(cls, name, contact, address):
new = Supplier(name=name, contact=contact, address=address)
try:
db.session.add(new)
db.session.commit()
return True
except Exception as e:
cls.add_error(e)
db.session.rollback()
return False
class Module(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String)
owner_id = db.Column(db.Integer)
img = db.Column(db.String(80))
def __init__(self, name, description, owner_id, img):
self.name = name
self.description = description
self.owner_id = owner_id
self.img = img
def serialize(self):
return {
"id": self.id,
"name": self.name,
"description": self.description,
"owner_id": self.owner_id,
"imd": self.img
}
def add_a_module_by_enity(module):
db.session.add(module)
db.session.commit()
return module.serialize()
def update_a_module_by_enity(module_new):
module_old = Module.query.filter_by(id=module_new.id).first()
if module_old is not None:
module_old.name = module_new.name
module_old.description = module_new.description
db.session.commit()
return True
else:
return False
class TransactionMedium(STModel):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(NAME_LENGTH),
index=True,
nullable=False,
unique=True)
sale_transactions = db.relationship('SaleTransaction',
backref='transaction_medium',
lazy='dynamic')
@classmethod
def check_exist(cls, name):
return db.session.query(
exists().where(TransactionMedium.name == name)).scalar()
@classmethod
def try_add(cls, name):
new_tm = TransactionMedium(name=name)
try:
db.session.add(new_tm)
db.session.commit()
return True
except Exception as e:
cls.add_error(e)
db.session.rollback()
return False
@classmethod
def get_list(cls,
page_num=DEFAULT_PAGE_NUMBER,
list_per_page=DEFAULT_POSTS_PER_PAGE,
include_header=True,
order_by=None,
**kwargs):
q = TransactionMedium.query.with_entities(TransactionMedium.id,
TransactionMedium.name)
q = paginate_query(q, page_num, list_per_page)
if order_by:
q = q.order_by(order_by)
tm_list = q.all()
if include_header:
tm_list.insert(0, tuple(x['name'] for x in q.column_descriptions))
return tm_list
class question(db.Model):
__tablename__ = 'question'
questionID = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
description = db.Column(db.String(600), nullable=False)
testQuestions = db.relationship('test_question', backref='question', lazy='joined')
# 16/03/2021 - Create relationship between question and option classes, in order to load the multiple options related to a single question
# A relationship will allow for both questions and options to be pulled from the database together in a single query statement
options = db.relationship('option', backref='question', lazy='joined')
# 24/03/2021 - Create a relationship between question and answer classes, in order to load the option the user selected to answer the current question
answer = db.relationship('answer', backref='question', lazy='joined')
# This function should be return a printable representation of the question object
def __repr__(self):
return '<question: {}>'.format(self.description)
class UserRoleRepo(Base):
__tablename__ = 'user_roles_m'
role_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
role_type = db.Column(db.String(64), nullable=False)
EmployeeDetailsRepo = relationship("EmployeeDetailsRepo",
cascade="all,delete",
backref="UserRoleRepo",
lazy='joined')
def __repr__(self):
return "<UserRoleRepo(role_id='{}',role_type='{}')>".format(
self.role_id, self.role_type)
def get_json(self):
body = {"role_id": self.role_id, "role_type": self.role_type}
return body
class AssessmentCompletionStatusRepo(Base):
__tablename__ = 'assessment_completion_status_m'
status_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
status_type = db.Column(db.String(20), nullable=False)
ParticipantsAssessmentStatus = relationship(
"ParticipantsAssessmentStatus",
cascade="all,delete",
backref="AssessmentCompletionStatusRepo")
def __repr__(self):
return "<AssessmentCompletionStatusRepo(status_id='{}',status_type='{}')>".format(
self.status_id, self.status_type)
def get_json(self):
body = {"status_id": self.status_id, "status_type": self.status_type}
return body
class FeedBackLevelRepo(Base):
__tablename__ = 'feedback_level_m'
level_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
level_type = db.Column(db.String(20), nullable=False)
FeedBackStatements = relationship("FeedBackStatements",
cascade="all,delete",
backref="FeedBackLevelRepo",
lazy='joined')
def __repr__(self):
return "<FeedBackLevelRepo(level_id='{}',level_type='{}')>".format(
self.level_id, self.level_type)
def get_json(self):
body = {"level_id": self.level_id, "level_type": self.level_type}
return body
class Course(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String)
module = db.Column(db.Integer)
def __init__(self, name, description, module):
self.name = name
self.description = description
self.module = module
def serialize(self):
return {
"id": self.id,
"name": self.name,
"description": self.description,
"module": self.module
}
