My Blog

Peer-to-Peer (P2P) Insurance Models

—

by

tayyaba
in

Install Required Libraries

Install Flask, Flask-SQLAlchemy, and Flask-Login:

bashCopy codepip install flask flask-sqlalchemy flask-login flask-wtf
  • Flask-SQLAlchemy: For database management.
  • Flask-Login: For user authentication.
  • Flask-WTF: For form handling.

Step 2: Define Database Models

We need to define a few database models:

  1. User: Stores user information and account credentials.
  2. InsurancePool: Represents an insurance pool to which users can join and contribute.
  3. Contribution: Tracks contributions to each pool by users.
  4. Claim: Tracks claims filed by users in a pool.

models.py

pythonCopy codefrom flask_sqlalchemy import SQLAlchemy
from datetime import datetime

db = SQLAlchemy()

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password_hash = db.Column(db.String(128), nullable=False)
    pools = db.relationship('InsurancePool', backref='creator', lazy=True)
    contributions = db.relationship('Contribution', backref='user', lazy=True)
    claims = db.relationship('Claim', backref='claimant', lazy=True)

    def __repr__(self):
        return f'<User {self.username}>'

class InsurancePool(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(120), nullable=False)
    description = db.Column(db.String(255), nullable=False)
    total_fund = db.Column(db.Float, default=0.0)  # Total fund collected from contributions
    creator_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    contributions = db.relationship('Contribution', backref='pool', lazy=True)
    claims = db.relationship('Claim', backref='pool', lazy=True)

    def __repr__(self):
        return f'<InsurancePool {self.name}>'

class Contribution(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    amount = db.Column(db.Float, nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    pool_id = db.Column(db.Integer, db.ForeignKey('insurance_pool.id'), nullable=False)

    def __repr__(self):
        return f'<Contribution {self.amount} from {self.user_id} to pool {self.pool_id}>'

class Claim(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    claim_amount = db.Column(db.Float, nullable=False)
    description = db.Column(db.String(255), nullable=False)
    claim_date = db.Column(db.DateTime, default=datetime.utcnow)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    pool_id = db.Column(db.Integer, db.ForeignKey('insurance_pool.id'), nullable=False)
    status = db.Column(db.String(50), default='Pending')  # Claim status (Pending, Approved, Denied)

    def __repr__(self):
        return f'<Claim {self.claim_amount} for user {self.user_id} in pool {self.pool_id}>'

Step 3: Flask Application Setup

We’ll set up routes for:

  • User Registration & Login: To allow users to create accounts and log in.
  • Insurance Pool Creation: To allow users to create an insurance pool.
  • Join Pool: To allow users to join an existing insurance pool.
  • Make Contribution: To allow users to contribute to a pool.
  • File Claims: To allow users to file claims.

app.py

pythonCopy codefrom flask import Flask, render_template, request, redirect, url_for, flash
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user
from werkzeug.security import generate_password_hash, check_password_hash
from models import db, User, InsurancePool, Contribution, Claim

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///p2p_insurance.db'
db.init_app(app)

login_manager = LoginManager(app)
login_manager.login_view = 'login'

# User loader for Flask-Login
@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))

# Routes
@app.route('/')
def index():
    return render_template('index.html')

@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'POST':
        username = request.form['username']
        email = request.form['email']
        password = request.form['password']
        password_hash = generate_password_hash(password)

        new_user = User(username=username, email=email, password_hash=password_hash)
        db.session.add(new_user)
        db.session.commit()

        flash('Account created successfully! You can now log in.', 'success')
        return redirect(url_for('login'))

    return render_template('register.html')

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        email = request.form['email']
        password = request.form['password']
        user = User.query.filter_by(email=email).first()

        if user and check_password_hash(user.password_hash, password):
            login_user(user)
            return redirect(url_for('dashboard'))

        flash('Login failed. Check your email or password.', 'danger')

    return render_template('login.html')

@app.route('/dashboard')
@login_required
def dashboard():
    # Get all insurance pools created by the current user
    pools = InsurancePool.query.filter_by(creator_id=current_user.id).all()
    joined_pools = InsurancePool.query.join(Contribution).filter(Contribution.user_id == current_user.id).all()
    return render_template('dashboard.html', pools=pools, joined_pools=joined_pools)

@app.route('/create_pool', methods=['GET', 'POST'])
@login_required
def create_pool():
    if request.method == 'POST':
        name = request.form['name']
        description = request.form['description']
        new_pool = InsurancePool(name=name, description=description, creator_id=current_user.id)
        db.session.add(new_pool)
        db.session.commit()

        flash('Insurance pool created successfully!', 'success')
        return redirect(url_for('dashboard'))

    return render_template('create_pool.html')

@app.route('/join_pool/<int:pool_id>', methods=['GET', 'POST'])
@login_required
def join_pool(pool_id):
    pool = InsurancePool.query.get_or_404(pool_id)

    if request.method == 'POST':
        amount = float(request.form['amount'])
        contribution = Contribution(amount=amount, user_id=current_user.id, pool_id=pool.id)
        pool.total_fund += amount  # Increase pool's total fund
        db.session.add(contribution)
        db.session.commit()

        flash('Joined pool and contributed!', 'success')
        return redirect(url_for('dashboard'))

    return render_template('join_pool.html', pool=pool)

@app.route('/file_claim/<int:pool_id>', methods=['GET', 'POST'])
@login_required
def file_claim(pool_id):
    pool = InsurancePool.query.get_or_404(pool_id)

    if request.method == 'POST':
        claim_amount = float(request.form['claim_amount'])
        description = request.form['description']
        new_claim = Claim(claim_amount=claim_amount, description=description, user_id=current_user.id, pool_id=pool.id)
        db.session.add(new_claim)
        db.session.commit()

        flash('Claim filed successfully and is under review.', 'success')
        return redirect(url_for('dashboard'))

    return render_template('file_claim.html', pool=pool)

@app.route('/logout')
@login_required
def logout():
    logout_user()
    return redirect(url_for('index'))

if __name__ == '__main__':
    app.run(debug=True)

Step 4: Create the Frontend Templates

templates/index.html

htmlCopy code<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *