class County(db.Model):
__tablename__ = 'county'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
county_name = db.Column(db.String(50), unique=True, nullable=False)
constituency = db.relationship("Constituency", backref="county")
ward = db.relationship("Ward", backref="county")
def __init__(self, county_name):
self.county_name = county_name
def serialize(self):
return {"id": self.id, "name": self.county_name}
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_county_by_name(cls, name):
county = cls.query.filter_by(county_name=name).first()
return county.id
@classmethod
def get_county_by_id(cls, id):
county = cls.query.filter_by(id=id).first()
return county
@classmethod
def get_all_counties(cls):
counties = [c.serialize() for c in cls.query.all()]
return counties
class UsersModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), nullable=False)
password = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), nullable=False)
location = db.relationship('LocationsModel', backref='user', uselist=False)
passInfo = db.relationship('PassesModel', backref='user', uselist=False)
favorites = db.Column(db.Text, nullable=False)
def __init__(self, username, password, email):
self.username = username
self.password = password
self.email = email
self.favorites = '[]'
def save_to_db(self):
db.session.add(self)
db.session.commit()
def remove_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def find_user_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_user_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_user_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def update_favorites(cls, _id, new_fav):
user = cls.query.filter_by(id=_id).first()
user.favorites = new_fav
db.session.commit()
# Checks whether the user_id has favorited target_id
# If so, returns true, else false
@classmethod
def is_fav(cls, user_id, target_id):
user = cls.query.filter_by(id=user_id).first()
is_fav = False
fav_list = json.loads(user.favorites)
for fav in fav_list:
if (int(fav["key"]) == target_id):
is_fav = True
return is_fav
class CompanyModel(db.Model, Model):
"""
CompanyModel Class
This class contains only CompanyModel methods and represents the companies table in database.
"""
__tablename__ = 'companies'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
position = db.Column(db.String(100), nullable=False)
assignments = db.Column(db.String(1000))
started_at = db.Column(db.Date(), nullable=False, default=datetime.date.today())
ended_at = db.Column(db.Date())
segment_id = db.Column(db.Integer, db.ForeignKey('segments.id'), nullable=False, default=1)
segment = db.relationship('SegmentModel')
products = db.relationship('ProductModel', lazy='dynamic')
presentations = db.relationship('PresentationModel', lazy='dynamic')
def __init__(self, name: str, position: str, assignments: str, started_at: datetime, segment_id: int,
ended_at: datetime = None, _id: int = None) -> None:
"""
Loads a CompanyModel.
"""
self.id = _id
self.name = name
self.position = position
self.assignments = assignments
self.started_at = string_to_date(started_at)
self.ended_at = string_to_date(ended_at) if ended_at else None
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a CompanyModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'position': self.position,
'assignments': self.assignments,
'started_at': self.started_at.isoformat(),
'ended_at': self.ended_at.isoformat() if self.ended_at else None,
'segment': {'id': self.segment.id, 'name': self.segment.name},
'products': [product.json() for product in self.products.all()],
'presentations': [presentation.json() for presentation in self.presentations.all()]
}
def curriculum_json(self) -> dict:
"""
Retruns a reduced CompanyModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'position': self.position,
'started_at': self.started_at.isoformat(),
'ended_at': self.ended_at.isoformat() if self.ended_at else None
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, unique=True, nullable=False)
fullname = db.Column(db.String, nullable=False)
gender = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
user_info = db.relationship('UserInfo',backref='user',lazy=True)
my_stores = db.relationship('Store', backref='user',lazy=True)
store_dropped=db.relationship('StoreRelation', backref='user',lazy=True)
class Store(db.Model):
id = db.Column(db.Integer, primary_key=True)
store_name = db.Column(db.String, nullable=False, unique=True)
store_cover = db.Column(db.String, nullable=True)
store_photo = db.Column(db.String, nullable=True)
store_category = db.Column(db.String, nullable=True)
store_description = db.Column(db.String, nullable=True)
items = db.relationship('Item', backref='store', lazy=True)
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'))
dropers = db.relationship('StoreRelation', backref='store', lazy=True)
class PresentationModel(db.Model, Model):
"""
PresentationModel Class
This class contains only PresentationModel methods and represents the presentations table in database.
"""
__tablename__ = 'presentations'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
performed_at = db.Column(db.Date(), nullable=False, default=datetime.date.today())
city = db.Column(db.String(250), nullable=False)
state = db.Column(db.String(250))
country = db.Column(db.String(250), nullable=False)
segment_id = db.Column(db.Integer, db.ForeignKey('segments.id'), nullable=False, default=1)
segment = db.relationship('SegmentModel')
company_id = db.Column(db.Integer, db.ForeignKey('companies.id'))
company = db.relationship('CompanyModel')
def __init__(self, name: str, performed_at: datetime, city: str, country: str, segment_id: int, state: str = None,
company_id: int = None, _id: int = None) -> None:
"""
Loads a PresentationModel.
"""
self.id = _id
self.name = name
self.performed_at = string_to_date(performed_at)
self.city = city
self.state = state if state else None
self.country = country
self.segment_id = segment_id
self.company_id = company_id
def json(self) -> dict:
"""
Retruns a PresentationModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'performed_at': self.performed_at.isoformat(),
'city': self.city,
'state': self.state if self.state else None,
'country': self.country,
'segment': {'id': self.segment.id, 'name': self.segment.name},
'company': {'id': self.company.id, 'name': self.company.name} if self.company else None
}
def curriculum_json(self) -> dict:
"""
Retruns a reduced PresentationModel as a json format.
"""
return {'id': self.id, 'name': self.name, 'performed_at': self.performed_at.isoformat()}
class TiedAgents(db.Model):
"""
Tied Agents model
"""
__tablename__ = 'tied_agent'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
# The tied agent is linked to a user profile since they have common details
user_id = db.Column(db.Integer, db.ForeignKey(
'user.id', ondelete='CASCADE', onupdate='CASCADE'))
ta_customer = db.relationship("TACustomer", backref="ta_affiliation")
ta_staff = db.relationship("TAStaff", backref="ta_member")
def __init__(self, user_id):
self.user_id = user_id
def __repr__(self):
return f"{self.id}"
def serialize(self):
return self.user.serialize()
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_all_tied_agents(cls):
tied_agents_rows = cls.query.all()
tied_agents = [{
"id": agent.id,
"user": agent.user
} for agent in tied_agents_rows]
return tied_agents
@classmethod
def get_tied_agent_by_id(cls, agent_id):
return cls.query.filter_by(id=agent_id).first()
@classmethod
def get_tied_agent_by_user_id(cls, user_id):
return cls.query.filter_by(user_id=user_id).first()
class ProjectsModel(db.Model):
__tablename__ = "projects"
project_code = db.Column(db.String(8), primary_key=True)
trimesters = db.Column(db.Integer)
degree = db.Column(db.Boolean)
diploma = db.Column(db.Boolean)
students = db.relationship(StudentsModel, backref="projects", cascade="all, delete, delete-orphan")
allocations=db.relationship(AllocationsModel, backref="projects", cascade="all, delete, delete-orphan")
def __init__(self, project_code, trimesters, degree, diploma):
self.project_code = project_code
self.trimesters = trimesters
self.degree = degree
self.diploma = diploma
def serialize(self):
"""return json formatted data"""
return {
"project_code": self.project_code,
"trimesters": self.trimesters,
"degree": self.degree,
"diploma": self.diploma
}, 200
def save_project(self):
"""add a new project to the database"""
db.session.add(self)
db.session.commit()
@staticmethod
def update_project():
db.session.commit()
def remove_project(self):
db.sesion.delete(self)
db.session.commit()
@classmethod
def fetch_all_projects(cls):
project_rows = cls.query.all()
all_projects = [{
"project_code": project.project_code,
"trimesters": project.trimesters,
"degree": project.degree,
"diploma": project.diploma
} for project in project_rows]
return all_projects
@classmethod
def fetch_project_by_code(cls, project_code):
return cls.query.filter_by(project_code=project_code).first()
class User(TimestampMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String, nullable=False)
age = db.Column(db.Integer, nullable=False)
address = db.relationship('Address',
uselist=False,
backref='users',
cascade='all, delete')
def __init__(self, name, age):
self.name = name
self.age = age
def __repr__(self):
return "User(name='{}', age={}, address={})".format(
self.name, self.age, self.address)
def serialize(self):
return {
'id': self.id,
'name': self.name,
'age': self.age,
'address': {
'street': self.address.street,
'number': self.address.number,
'city': self.address.city,
'state': self.address.state
}
}
@classmethod
def from_json(cls, json):
return cls(json['name'], json['age'])
class SkillModel(db.Model, Model):
"""
SkillModel Class
This class contains only SkillModel methods and represents the skills table in database.
"""
__tablename__ = 'skills'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False, unique=True)
description = db.Column(db.String(1000), nullable=False)
level = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.Date(),
nullable=False,
default=datetime.date.today(),
unique=True)
segment_id = db.Column(db.Integer,
db.ForeignKey('segments.id'),
nullable=False,
default=1)
segment = db.relationship('SegmentModel')
def __init__(self,
name: str,
description: str,
level: int,
segment_id: int,
_id: int = None) -> None:
"""
Loads a SkillModel.
"""
self.id = _id
self.name = name
self.description = description
self.level = level
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a SkillModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'description': self.description,
'level': self.level,
'created_at': self.created_at.isoformat(),
'segment': {
'id': self.segment.id,
'name': self.segment.name
}
}
def curriculum_json(self) -> dict:
"""
Retruns a reduced SkillModel as a json format.
"""
return {'id': self.id, 'name': self.name, 'level': self.level}
class GraduationModel(db.Model, Model):
"""
GraduationModel Class
This class contains only GraduationModel methods and represents the graduations table in database.
"""
__tablename__ = 'graduations'
id = db.Column(db.Integer, primary_key=True)
course = db.Column(db.String(50), nullable=False, unique=True)
institution = db.Column(db.String(100), nullable=False, unique=True)
started_at = db.Column(db.Date(),
nullable=False,
default=datetime.date.today(),
unique=True)
ended_at = db.Column(db.Date())
segment_id = db.Column(db.Integer,
db.ForeignKey('segments.id'),
nullable=False,
default=1)
segment = db.relationship('SegmentModel')
def __init__(self,
course: str,
institution: str,
started_at: datetime,
segment_id: int,
ended_at: datetime = None,
_id: int = None) -> None:
"""
Loads a GraduationModel.
"""
self.id = _id
self.course = course
self.institution = institution
self.started_at = string_to_date(started_at)
self.ended_at = string_to_date(ended_at) if ended_at else None
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a GraduationModel as a json format.
"""
return {
'id': self.id,
'course': self.course,
'institution': self.institution,
'started_at': self.started_at.isoformat(),
'ended_at': self.ended_at.isoformat() if self.ended_at else None,
'segment': {
'id': self.segment.id,
'name': self.segment.name
}
}
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
name = db.Column(db.String(20), unique=False, nullable=False)
surname = db.Column(db.String(20), unique=False, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Posts', backref='author', lazy=True)
def __repr__(self):
return f'Users("{self.username}", "{self.email}", "{self.password}")'
class Categories(db.Model):
id = db.Column(db.Integer, primary_key=True)
postid = db.relationship('Posts',
backref='category',
lazy=True,
order_by="Posts.id.desc()")
name = db.Column(db.String(), nullable=False)
description = db.Column(db.String(), nullable=True)
def __init__(self, name, description):
self.name = name
self.description = description
class Benefit(db.Model):
__tablename__ = 'benefit'
"A list of benefits to be added by insurance companies for various policies"
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False)
name = db.Column(db.String(100))
ic_benefit = db.relationship('ICBenefits',
backref="benefit",
cascade="all, delete, delete-orphan")
# class_code = db.Column(db.Integer, db.ForeignKey('insurance_class.class_id', onupdate='CASCADE',
# ondelete='CASCADE'))
def __init__(self, name):
self.name = name
# self.class_code = class_code
def __repr__(self):
return f"{self.name}"
def save(self):
db.session.add(self)
db.session.commit()
def serialize(self):
return {"id": self.id, "name": self.name}
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_benefit_by_name(cls, benefit_name):
benefit = cls.query.filter_by(name=benefit_name).first()
return benefit
@classmethod
def get_name_by_id(cls, benefit_id):
benefit = cls.query.filter_by(id=benefit_id).first()
return benefit.name
@classmethod
def get_all_benefits(cls):
benefit = [b.serialize() for b in cls.query.all()]
return benefit
class Role(db.Model):
"""
Pre defined list of roles in nexure for permission throttling
"""
__tablename__ = 'role'
# the role name will help us know what permissions to grant the user
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
role_name = db.Column(db.String(7), nullable=False, unique=True)
# define the relationship to the user role placement
user_role = db.relationship("UserRolePlacement", backref="role")
def __init__(self, role_name):
self.role_name = role_name
def __repr__(self):
return f"{self.role_name}"
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def fetch_all_roles(cls):
role_rows = cls.query.all()
roles = [{
"role_name": role.role_name
} for role in role_rows]
return roles
@classmethod
def fetch_role_by_id(cls, role_id):
# Get user role by id
role_row = cls.query.filter_by(id=role_id).first()
return role_row.role_name
@classmethod
def fetch_role_by_name(cls, role_name):
# Get user role by name
role_row = cls.query.filter_by(role_name=role_name).first()
return role_row.id
class Permissions(db.Model):
__tablename__ = 'permission'
# stores the list of permissions
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
permission_name = db.Column(db.String(100))
user_permission = db.relationship('UserPermissions', backref='permissions')
def __init__(self, permission_name, user_id):
self.permission_name = permission_name
self.user_id = user_id
def __str__(self):
return f"{self.id}"
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False, unique=True)
comment = db.Column(db.String(200))
price = db.Column(db.Float, nullable=False)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('products', lazy=True))
def __init__(self, name, comment, price, category_id):
self.name = name
self.comment = comment
self.price = price
self.category_id = category_id
class InsuranceClass(db.Model):
"""
Insurance class
"""
__tablename__ = 'insurance_class'
class_id = db.Column(db.Integer, primary_key=True, nullable=False)
class_name = db.Column(db.String(50), unique=True, nullable=False)
acronym = db.Column(db.String(3), unique=True, nullable=False)
sector = db.Column(db.String(100), nullable=False)
subclass = db.relationship("InsuranceSubclass", backref="subclass")
licenced_classes = db.relationship('LicencedClasses', backref="classes",
cascade="all, delete, delete-orphan")
def __init__(self, class_id, class_name, acronym, sector):
self.class_id = class_id
self.class_name = class_name
self.acronym = acronym
self.sector = sector
def __repr__(self):
return f"{self.class_name}"
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_class_by_id(cls, id):
parent_class = cls.query.filter_by(class_id=id).first()
return parent_class
@classmethod
def get_class_by_name(cls, name):
iclass = cls.query.filter_by(class_name=name).first()
return iclass.class_id
class Loadings(db.Model):
__tablename__ = 'loading'
"""Contains loadings for a particular child policy"""
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False)
name = db.Column(db.String(100))
ic_loadings = db.relationship('ICLoadings',
backref='loading',
lazy='dynamic')
def __init__(self, name):
self.name = name
def __repr__(self):
return f"{self.name}"
def save(self):
db.session.add(self)
db.session.commit()
def serialize(self):
return {"id": self.id, "name": self.name}
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_loading_id_by_name(cls, loading_name):
loading = cls.query.filter_by(name=loading_name).first()
return loading.id
@classmethod
def get_name_by_id(cls, loading_id):
loading = cls.query.filter_by(id=loading_id).first()
return loading.name
@classmethod
def get_all_loadings(cls):
loadings = [loading.serialize() for loading in cls.query.all()]
return loadings
class Driver(db.Model):
"""
Store driver details linked to a particular vehicle
"""
__tablename__ = 'driver'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
gender = db.Column(db.String(1))
# we need to store the user mobile number
# for subsequent communication
phone = db.Column(db.BIGINT, unique=True)
birth_date = db.Column(db.DateTime)
driver = db.relationship("VehicleDetails", backref="driver")
def __init__(self, first_name, last_name, gender, phone, birth_date):
self.first_name = first_name
self.last_name = last_name
self.gender = gender
self.phone = phone
self.birth_date = birth_date
def serialize(self):
return {
"first_name": self.first_name,
"last_name": self.last_name,
"phone": self.phone,
"birth_date": self.birth_date.strftime('%m/%d/%Y')
}
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.remove(self)
db.session.commit()
@classmethod
def get_driver_by_id(cls, id):
driver = cls.query.filter_by(id=id).first()
return driver
class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
description = db.Column(db.String(), nullable=True)
content = db.Column(db.String(), nullable=True)
tags = db.relationship('Tags',
secondary=relations,
backref=db.backref('tag'))
categories = db.Column(db.Integer(),
db.ForeignKey('categories.id'),
nullable=True)
author = db.Column(db.Integer(), db.ForeignKey('users.id'), nullable=True)
def __init__(self, name, description, content):
self.name = name
self.description = description
self.content = content
class CertificationModel(db.Model, Model):
"""
CertificationModel Class
This class contains only CertificationModel methods and represents the certifications table in database.
"""
__tablename__ = 'certifications'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
organization = db.Column(db.String(100), nullable=False, unique=True)
issued_at = db.Column(db.Date(), nullable=False, default=datetime.date.today(), unique=True)
expires_at = db.Column(db.Date())
segment_id = db.Column(db.Integer, db.ForeignKey('segments.id'), nullable=False, default=1)
segment = db.relationship('SegmentModel')
def __init__(self, name: str, organization: str, issued_at: datetime, segment_id: int, expires_at: datetime = None,
_id: int = None) -> None:
"""
Loads a CertificationModel.
"""
self.id = _id
self.name = name
self.organization = organization
self.issued_at = string_to_date(issued_at)
self.expires_at = string_to_date(expires_at) if expires_at else None
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a CertificationModel as a json format.
"""
return {
'id': self.id,
'name': self.name,
'organization': self.organization,
'issued_at': self.issued_at.isoformat(),
'expires_at': self.expires_at.isoformat() if self.expires_at else None,
'segment': {'id': self.segment.id, 'name': self.segment.name}
}
def curriculum_json(self) -> dict:
"""
Retruns a reduced CertificationModel as a json format.
"""
return {'id': self.id, 'name': self.name}
class Users(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
postid = db.relationship('Posts', backref='user', lazy=True)
account = db.Column(db.String(), nullable=False)
password_hash = db.Column(db.String(), nullable=False)
name = db.Column(db.String(), nullable=True)
introduction = db.Column(db.String(), nullable=True)
def __init__(self, account, password):
self.account = account
self.password_hash = generate_password_hash(password)
def change_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class Extension(db.Model):
__tablename__ = 'extension'
"""Contains extensions for a particular child polict"""
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False)
name = db.Column(db.String(100))
insurance_company = db.relationship('ICExtensions',
backref="extension",
cascade="all, delete, delete-orphan")
def __init__(self, name):
self.name = name
def save(self):
db.session.add(self)
db.session.commit()
def serialize(self):
return {"id": self.id, "name": self.name}
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_extension_id_by_name(cls, extension_name):
extension = cls.query.filter_by(name=extension_name).first()
return extension
@classmethod
def get_name_by_id(cls, extension_id):
extension = cls.query.filter_by(id=extension_id).first()
return extension.name
@classmethod
def get_all_extensions(cls):
extensions = [e.serialize() for e in cls.query.all()]
return extensions
class Comment(db.Model):
__tablename__ = 'comments'
__table_args__ = {'schema': 'flask'}
id = db.Column(db.Integer, primary_key=True)
comment = db.Column(db.String(255), nullable=False)
creation_date = db.Column(db.TIMESTAMP,
server_default=db.func.current_timestamp(),
nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey('flask.categories.id',
ondelete='CASCADE'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('comments', lazy='dynamic'))
def __init__(self, comment, category_id):
self.comment = comment
self.category_id = category_id
class ResumeModel(db.Model, Model):
"""
ResumeModel Class
This class contains only ResumeModel methods and represents the resumes table in database.
"""
__tablename__ = 'resumes'
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(1000), nullable=False)
created_at = db.Column(db.Date(),
nullable=False,
default=datetime.date.today())
segment_id = db.Column(db.Integer,
db.ForeignKey('segments.id'),
nullable=False,
default=1)
segment = db.relationship('SegmentModel')
def __init__(self,
description: str,
segment_id: int,
_id: int = None) -> None:
"""
Loads a ResumeModel.
"""
self.id = _id
self.description = description
self.segment_id = segment_id
def json(self) -> dict:
"""
Retruns a ResumeModel as a json format.
"""
return {
'id': self.id,
'description': self.description,
'created_at': self.created_at.isoformat(),
'segment': {
'id': self.segment.id,
'name': self.segment.name
}
}
class CarModel(db.Model):
"""
Stores car model
"""
__tablename__ = "car_model"
model_id = db.Column(db.Integer, primary_key=True, nullable=False)
model_name = db.Column(db.String(300), nullable=False)
series = db.Column(db.String(100), nullable=False)
make = db.Column(db.Integer, db.ForeignKey('car_make.make_id', ondelete='CASCADE', onupdate='CASCADE'))
# describe the relationship with the vehicle_details of a policy holder
vehicle_details = db.relationship("VehicleDetails", backref="car_model", lazy='dynamic')
def __init__(self, model_name, series, make):
self. model_name = model_name
self.series = series
self.make = make
def save(self):
db.session.add(self)
db.session.commit()
def serialize(self):
return {
"model_id": self.model_id,
"model_name": self.model_name,
"series": self.series
}
@classmethod
def get_models_by_make_id(cls, make_id):
car_models = cls.query.filter_by(make=make_id)
return car_models
@classmethod
def get_model_name_by_id(cls, model_id):
model = cls.query.filter_by(model_id=model_id).first()
return model.model_name
class CarMake(db.Model):
"""
Stores the car make and the make id
"""
__tablename__ = 'car_make'
make_id = db.Column(db.Integer, primary_key=True, nullable=False)
make_name = db.Column(db.String(50), unique=True, nullable=False)
car_model = db.relationship('CarModel',
backref='car_make',
cascade="all, delete,"
" delete-orphan")
def __init__(self, make_id, make_name):
self.make_id = make_id
self.make_name = make_name
def save(self):
db.session.add(self)
db.session.commit()
def serialize(self):
return {
"make_id": self.make_id,
"make_name": self.make_name,
"models": [m.serialize() for m in self.car_model]
}
@classmethod
def get_car_make_by_name(cls, name):
car = cls.query.filter_by(make_name=name).first()
return car.make_id
@classmethod
def get_all_car_makes(cls):
cars = [car.serialize() for car in cls.query.all()]
return cars
class Constituency(db.Model):
__tablename__ = 'constituency'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
name = db.Column(db.String(50), unique=True, nullable=False)
county_id = db.Column(
db.Integer,
db.ForeignKey('county.id', ondelete='CASCADE', onupdate='CASCADE'))
ward = db.relationship("Ward", backref="constituency")
def __init__(self, name, county):
self.name = name
self.county = county
def serialize(self):
return {
"id": self.id,
"name": self.name,
"county": self.county.county_name,
}
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_constituency_by_name(cls, name):
constituency = cls.query.filter_by(name=name).first()
return constituency.id
@classmethod
def get_all_constituencies(cls):
return [constituency.serialize() for constituency in cls.query.all()]
class ICExtensions(db.Model):
"""Stores the extensions
that offered by a company, for a particular policy, together with the rate and limits for them"""
__tablename__ = 'ic_extension'
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False)
insurance_company_id = db.Column(
db.Integer,
db.ForeignKey('insurance_company.id',
onupdate='CASCADE',
ondelete='CASCADE'))
extension_id = db.Column(
db.Integer,
db.ForeignKey('extension.id', onupdate='CASCADE', ondelete='CASCADE'))
free_limit = db.Column(db.Float, nullable=False)
max_limit = db.Column(db.Float, nullable=False)
rate = db.Column(db.Float, nullable=False)
policy_extension_id = db.relationship('PolicyExtensions',
backref="ic_extension")
def __init__(self, insurance_company_id, extension_id, free_limit,
max_limit, rate):
self.insurance_company_id = insurance_company_id
self.extension_id = extension_id
self.free_limit = free_limit
self.max_limit = max_limit
self.rate = rate
def serialize(self):
return {
"id": self.id,
"insurance_company":
self.insurance_company.company_details.company_name,
"name": self.extension.name,
"free_limit": self.free_limit,
"max_limit": self.max_limit,
"rate": self.rate
}
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_extensions_by_company_id(cls, company_id):
"""
Returns id, extension_id, free_limit, max_limit and rate for
every list of extensions under a particular company
"""
extension_rows = [
extension.serialize() for extension in cls.query.filter_by(
insurance_company_id=company_id).all()
]
return extension_rows
@classmethod
def get_ic_extension(cls, extension_id):
extension = cls.query.filter_by(extension_id=extension_id).first()
return extension
@classmethod
def get_extension_id(cls, id):
"""
Gets the IC Extension given the object id
"""
ic_extension = cls.query.filter_by(id=id).first()
return ic_extension
@classmethod
def get_unselected_extensions(cls, excluded_extensions):
extensions = cls.query.filter(cls.id.notin_(excluded_extensions))
return [extension.serialize() for extension in extensions]
