Health and Wellness Insurance Integration

—

by

Install Required Libraries

First, install the required libraries:

bashCopy codepip install flask flask-sqlalchemy flask-login flask-wtf requests

Step 2: Define Database Models

We will define models for:

User: Stores user information.
InsurancePolicy: Represents a health and wellness insurance policy.
WellnessActivity: Stores the user’s wellness data (e.g., steps, exercise hours, etc.).
Claim: Represents claims for insurance policies.

`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)
    wellness_data = db.relationship('WellnessActivity', backref='user', lazy=True)
    policies = db.relationship('InsurancePolicy', backref='holder', lazy=True)

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

class WellnessActivity(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    steps = db.Column(db.Integer, nullable=False)  # Number of steps walked
    exercise_hours = db.Column(db.Float, nullable=False)  # Hours of exercise
    calories_burned = db.Column(db.Integer, nullable=False)  # Calories burned
    date = db.Column(db.DateTime, default=datetime.utcnow)

    def __repr__(self):
        return f'<WellnessActivity {self.user_id} - {self.date}>'

class InsurancePolicy(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    product_name = db.Column(db.String(100), nullable=False)
    coverage = db.Column(db.Float, nullable=False)  # Coverage amount
    premium = db.Column(db.Float, nullable=False)  # Premium amount
    wellness_discount = db.Column(db.Float, default=0)  # Discount based on wellness activity

    def __repr__(self):
        return f'<InsurancePolicy {self.id}>'

class Claim(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    policy_id = db.Column(db.Integer, db.ForeignKey('insurance_policy.id'), nullable=False)
    amount = db.Column(db.Float, nullable=False)
    description = db.Column(db.String(255), nullable=False)
    status = db.Column(db.String(50), default='Pending')  # Pending, Approved, Denied
    date_filed = db.Column(db.DateTime, default=datetime.utcnow)

    def __repr__(self):
        return f'<Claim {self.id}>'

Step 3: Flask Application Setup

We will define the routes for:

User Registration and Login.
Viewing and Purchasing Health and Wellness Insurance Products.
Tracking and Integrating Wellness Activity (using simulated data).
Submitting Claims for health-related incidents.

`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, WellnessActivity, InsurancePolicy, Claim
import random
import requests

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///wellness_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))

@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():
    # Display user's insurance policies and wellness data
    user_policies = InsurancePolicy.query.filter_by(user_id=current_user.id).all()
    wellness_data = WellnessActivity.query.filter_by(user_id=current_user.id).order_by(WellnessActivity.date.desc()).limit(5).all()
    return render_template('dashboard.html', user_policies=user_policies, wellness_data=wellness_data)

@app.route('/wellness_data', methods=['POST'])
@login_required
def wellness_data():
    # Simulating integration with fitness data (e.g., from a wearable device)
    steps = random.randint(5000, 15000)  # Random steps data
    exercise_hours = round(random.uniform(0, 2), 2)  # Random exercise hours data
    calories_burned = steps * 0.04  # Assume 0.04 calories per step
    
    new_activity = WellnessActivity(user_id=current_user.id, steps=steps, exercise_hours=exercise_hours, calories_burned=int(calories_burned))
    db.session.add(new_activity)
    db.session.commit()

    flash('Wellness data updated successfully!', 'success')
    return redirect(url_for('dashboard'))

@app.route('/insurance_products')
@login_required
def insurance_products():
    # Display available insurance products
    products = [
        {"name": "Basic Health Insurance", "coverage": 100000, "premium": 500},
        {"name": "Advanced Health & Wellness Insurance", "coverage": 200000, "premium": 800},
        {"name": "Premium Wellness Package", "coverage": 500000, "premium": 1500},
    ]
    return render_template('insurance_products.html', products=products)

@app.route('/purchase_policy/<string:product_name>', methods=['POST'])
@login_required
def purchase_policy(product_name):
    # Calculate discount based on wellness activity
    wellness_activity = WellnessActivity.query.filter_by(user_id=current_user.id).order_by(WellnessActivity.date.desc()).first()
    if wellness_activity and wellness_activity.exercise_hours >= 1:
        wellness_discount = 0.1  # 10% discount for users who exercise at least 1 hour
    else:
        wellness_discount = 0
    
    # Set coverage and premium based on the product selected
    if product_name == "Basic Health Insurance":
        coverage = 100000
        premium = 500
    elif product_name == "Advanced Health & Wellness Insurance":
        coverage = 200000
        premium = 800
    else:
        coverage = 500000
        premium = 1500
    
    discounted_premium = premium * (1 - wellness_discount)
    
    new_policy = InsurancePolicy(
        user_id=current_user.id,
        product_name=product_name,
        coverage=coverage,
        premium=discounted_premium,
        wellness_discount=wellness_discount * 100
    )
    db.session.add(new_policy)
    db.session.commit()

    flash(f'Policy "{product_name}" purchased successfully! Discount applied: {wellness_discount * 100}%', 'success')
    return redirect(url_for('dashboard'))

@app.route('/file_claim/<int:policy_id>', methods=['GET',

4o mini

Comments

Leave a Reply Cancel reply