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]