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