class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, unique=True)
name = db.Column(db.String)
age = db.Column(db.Integer)
def __init__(self, username, name, age):
self.username = username
self.name = name
self.age = age
def __repr__(self):
return f'{self.username}'
def get(self, **kwargs):
if kwargs:
return User.query.filter_by(**kwargs)
else:
return User.query.all()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
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 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 Historico(db.Model):
idhistorico = db.Column(db.Integer,
primary_key=True,
autoincrement=False,
nullable=False,
unique=False)
idcidade = db.Column(db.Integer,
primary_key=False,
autoincrement=False,
nullable=False,
unique=False)
idindicador = db.Column(db.Integer,
primary_key=False,
autoincrement=False,
nullable=False,
unique=False)
ano = db.Column(db.Integer,
primary_key=False,
autoincrement=False,
nullable=False,
unique=False)
valor = db.Column(db.String(200))
def __init__(self, idcidade, idindicador, ano, valor):
self.idcidade = idcidade
self.idindicador = idindicador
self.ano = ano
self.valor = valor
class InsuranceSubclass(db.Model):
__tablename__ = 'insurance_subclass'
class_code = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(50), nullable=False)
parent_class = db.Column(db.Integer, db.ForeignKey(
'insurance_class.class_id', ondelete='CASCADE', onupdate='CASCADE'))
acronym = db.Column(db.String(50), nullable=True)
def __init__(self, class_code, name, parent_class, acronym):
self.name = name
self.class_code = class_code
self.parent_class = parent_class
self.acronym = acronym
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()
@classmethod
def get_class_by_id(cls, code):
subclass = cls.query.filter_by(class_code=code).first()
return subclass
@classmethod
def get_acronym(cls, id):
subclass = cls.query.filter_by(class_code=id).first()
return subclass.acronym
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True)
email = db.Column(db.String(100), unique=False)
password = db.Column(db.String(80))
class AgeData(db.Model):
"""
Stores age bands, their data and the relativity.
"""
id = db.Column(db.Integer, autoincrement=True,
primary_key=True, nullable=False)
data = db.Column(db.Integer, nullable=False)
lower_limit = db.Column(db.Integer, nullable=False)
upper_limit = db.Column(db.Integer, nullable=False)
relativity = db.Column(db.Float, nullable=False)
def __init__(self, data, lower_limit, upper_limit, relativity):
self.data = data
self.lower_limit = lower_limit
self.upper_limit = upper_limit
self.relativity = relativity
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()
class Levies(db.Model):
__tablename__ = 'levies'
"""Contains levies for a particular child policy"""
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False)
name = db.Column(db.String(100))
rate = db.Column(db.Float, nullable=False)
def __init__(self, name, rate):
self.name = name
self.rate = rate
def __repr__(self):
return f"{self.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 get_all_levies(cls):
levies = cls.query.all()
return levies
class SumInsuredRates(db.Model):
"""
Stores sum insured rates, with their band limits and relativity
"""
id = db.Column(db.Integer,
primary_key=True,
auto_increment=True,
nullable=False)
lower_limit = db.Column(db.Integer, nullable=False)
upper_limit = db.Column(db.Integer, nullable=False)
relativity = db.Column(db.Float, nullable=False)
rate = db.Column(db.Float, nullable=False)
def __init__(self, lower_limit, upper_limit, relativity, rate):
self.lower_limit = lower_limit
self.upper_limit = upper_limit
self.relativity = relativity
self.rate = 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()
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String())
def __init__(self, username, password):
self.username = username
self.password = password
def json(self):
return {"id": self.id, "username": self.username}, 200
# Method to save user to DB
def save_to_db(self):
db.session.add(self)
db.session.commit()
# Method to remove user from DB
def remove_from_db(self):
db.session.delete(self)
db.session.commit()
# Class method which finds user from DB by username
@classmethod
def find_user_by_username(cls, username):
return cls.query.filter_by(username=username).first()
# Class method which finds user from DB by id
@classmethod
def find_user_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class Tags(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
description = db.Column(db.String(), nullable=True)
def __init__(self, name, description):
self.name = name
self.description = description
class WeatherObservation(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
city = db.Column(db.String, nullable=False)
text = db.Column(db.String, nullable=False)
datetime = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return f'<WeatherObservation {self.id} {self.city} {self.text}>'
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 Category(db.Model):
__tablename__ = 'categories'
__table_args__ = {'schema': 'flask'}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, nullable=False)
def __init__(self, name):
self.name = name
class Loss(db.Model):
""" Keeps track of losers in each game. """
__tablename__ = "losses"
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
game_id = db.Column(db.Integer,
db.ForeignKey('games.id'),
primary_key=True)
class PolicyBenefits(db.Model):
"""
Links benefits offered by the insurance company to a particular child policy.
Also contains the limit and the premium paid by the customer for the benefit
"""
__tablename__ = 'policy_benefits'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
policy_id = db.Column(
db.Integer,
db.ForeignKey('child_policy.id',
ondelete='CASCADE',
onupdate='CASCADE'))
ic_benefit_id = db.Column(
db.Integer,
db.ForeignKey('ic_benefit.id', ondelete='CASCADE', onupdate='CASCADE'))
amount = db.Column(db.Float, nullable=False)
def __init__(self, policy_id, ic_benefit_id, amount):
self.policy_id = policy_id
self.ic_benefit_id = ic_benefit_id
self.amount = amount
def serialize(self):
data = self.ic_benefit.serialize()
# We need the actual policy_id for this object, so pop the ic_benefit id and add the policy_benefits id instead
data.pop("id")
data.update({"amount_paid": self.amount, "id": self.id})
return data
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_policy_benefit_by_policy(cls, child_policy_id):
benefit_set = set()
benefits = cls.query.filter_by(policy_id=child_policy_id)
for benefit in benefits:
benefit_set.add(benefit.ic_benefit_id)
return benefit_set
@classmethod
def get_policy_benefit_by_id(cls, id):
benefit = cls.query.filter_by(id=id).first()
return benefit
class Pages(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)
def __init__(self, name, description, content):
self.name = name
self.description = description
self.content = content
class GamePlayed(db.Model):
""" Keeps track of every game a user has joined. """
__tablename__ = 'games_played'
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
game_id = db.Column(db.Integer,
db.ForeignKey('games.id'),
primary_key=True)
join_position = db.Column(db.Integer, nullable=False)
class PolicyPayments(db.Model):
"""
Describes all the transactions for a particular child policy, for both credit(payments) and debit(refunds)
"""
__tablename__ = 'policy_payments'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# transaction type can either be mpesa, bankers cheque, refund
transaction_type = db.Column(db.String(10))
amount = db.Column(db.Float, nullable=False)
customer_no = db.Column(db.String(50))
child_policy_id = db.Column(
db.Integer,
db.ForeignKey('child_policy.id',
ondelete='CASCADE',
onupdate='CASCADE'))
next_date = db.Column(db.DateTime)
amount_due = db.Column(db.Float, nullable=False, default=0)
# could be the mpesa code, or cheque number
transaction_code = db.Column(db.String(25))
date_paid = db.Column(db.DateTime, default=db.func.now())
def __init__(self, transaction_type, amount, customer_no, child_policy_id,
next_date, amount_due, transaction_code):
self.transaction_type = transaction_type
self.amount = amount
self.customer_no = customer_no
self.child_policy_id = child_policy_id
self.next_date = next_date
self.amount_due = amount_due
self.transaction_code = transaction_code
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 total_amount_paid(cls, child_id):
"""
Get total amount paid for a particular child policy
"""
amounts = [
t.amount for t in cls.query.filter_by(child_policy=child_id).all()
]
return sum(amounts)
@classmethod
def get_payments_history(cls, child_id):
return [
installment.serialize()
for installment in cls.query.filter_by(child_id=child_id).all()
]
class Indicador(db.Model):
idindicador = db.Column(db.Integer,
primary_key=True,
autoincrement=False,
nullable=False,
unique=True)
indicador = db.Column(db.String(200))
def __init__(self, idindicador, indicador):
self.idindicador = idindicador
self.indicador = indicador
class Pesquisa(db.Model):
idpesquisa = db.Column(db.Integer,
primary_key=True,
autoincrement=False,
nullable=False,
unique=True)
nome = db.Column(db.String(100))
def __init__(self, idpesquisa, nome):
self.idpesquisa = idpesquisa
self.nome = nome
class Cidade(db.Model):
idcidade = db.Column(db.Integer,
primary_key=True,
autoincrement=False,
nullable=False,
unique=True)
nome = db.Column(db.String(100))
def __init__(self, idcidade, nome):
self.idcidade = idcidade
self.nome = nome
class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), nullable=False)
content = db.Column(db.Text(300), nullable=False)
posted_date = db.Column(db.DateTime,
nullable=False,
default=datetime.now())
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
def __repr__(self):
return f'Users("{self.title}", "{self.posted_date}")'
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 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 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 IndividualCustomer(db.Model):
"""
Individual customer user
linked to the UserProfile
"""
# ToDo: Serialize the individual customer data
__tablename__ = 'individual_customer'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
customer_number = db.Column(db.String(50))
user_id = db.Column(db.Integer, db.ForeignKey(
'user.id', ondelete='CASCADE', onupdate='CASCADE'))
salutation = db.Column(db.String(10), nullable=False)
def __repr__(self):
return f"{self.user}"
def __init__(self, user_id, customer_number, salutation):
self.user_id = user_id
self.salutation = salutation
self.customer_number = customer_number
def serialize(self):
customer_profile = {
"customer_number": self.customer_number,
"salutation": self.salutation
}
customer_profile.update(self.user.serialize())
return customer_profile
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_customer_by_user_id(cls, uid):
return cls.query.filter_by(user_id=uid).first()
@classmethod
def get_customer_number(cls, uid):
customer = cls.query.filter_by(user_id=uid).first()
return customer.customer_number
