Install Required Libraries
To get started, install the required libraries:
bashCopy codepip install flask flask-sqlalchemy flask-login requests flask-wtf
Step 2: Define Database Models
We need to define several models:
- User: Stores user information and credentials.
- InsurancePolicy: Represents an insurance policy taken by the user.
- Claim: Represents claims filed by users.
- NaturalDisasterRisk: Stores risk data based on geographical location and disaster type.
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)
policies = db.relationship('InsurancePolicy', backref='holder', lazy=True)
claims = db.relationship('Claim', backref='claimant', lazy=True)
def __repr__(self):
return f'<User {self.username}>'
class InsurancePolicy(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
risk_level = db.Column(db.String(50), nullable=False)
coverage_amount = db.Column(db.Float, nullable=False)
premium = db.Column(db.Float, nullable=False)
status = db.Column(db.String(50), default="Active") # Active or Cancelled
start_date = db.Column(db.DateTime, default=datetime.utcnow)
end_date = db.Column(db.DateTime)
claims = db.relationship('Claim', backref='policy', lazy=True)
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}>'
class NaturalDisasterRisk(db.Model):
id = db.Column(db.Integer, primary_key=True)
location = db.Column(db.String(100), nullable=False)
disaster_type = db.Column(db.String(50), nullable=False) # Flood, Earthquake, etc.
risk_level = db.Column(db.String(50), nullable=False) # Low, Medium, High
description = db.Column(db.String(255), nullable=False)
risk_score = db.Column(db.Float, nullable=False) # Numeric risk score based on API data
def __repr__(self):
return f'<NaturalDisasterRisk {self.location} - {self.disaster_type}>'
Step 3: Flask Application Setup
In this step, we’ll set up the routes for the application.
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, InsurancePolicy, Claim, NaturalDisasterRisk
import requests
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///disaster_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():
# Show user's insurance policies and available disaster risks
user_policies = InsurancePolicy.query.filter_by(user_id=current_user.id).all()
disaster_risks = NaturalDisasterRisk.query.all()
return render_template('dashboard.html', user_policies=user_policies, disaster_risks=disaster_risks)
@app.route('/buy_policy/<int:risk_id>', methods=['POST'])
@login_required
def buy_policy(risk_id):
risk = NaturalDisasterRisk.query.get_or_404(risk_id)
coverage_amount = float(request.form['coverage_amount'])
premium = coverage_amount * 0.05 # Simple logic: premium is 5% of coverage amount
new_policy = InsurancePolicy(
user_id=current_user.id,
risk_level=risk.risk_level,
coverage_amount=coverage_amount,
premium=premium
)
db.session.add(new_policy)
db.session.commit()
flash('Policy purchased successfully!', 'success')
return redirect(url_for('dashboard'))
@app.route('/file_claim/<int:policy_id>', methods=['GET', 'POST'])
@login_required
def file_claim(policy_id):
policy = InsurancePolicy.query.get_or_404(policy_id)
if request.method == 'POST':
claim_amount = float(request.form['claim_amount'])
description = request.form['description']
new_claim = Claim(
policy_id=policy.id,
amount=claim_amount,
description=description
)
db.session.add(new_claim)
db.session.commit()
flash('Claim submitted successfully!', 'success')
return redirect(url_for('dashboard'))
return render_template('file_claim.html', policy=policy)
@app.route('/logout')
@login_required
def logout():
logout_user()
return redirect(url_for('index'))
# Function to fetch disaster risk data from external API
def get_disaster_risk(location):
api_key = 'YOUR_OPENWEATHERMAP_API_KEY'
url = f'http://api.openweathermap.org/data/2.5/weather?q={location}&appid={api_key}'
response = requests.get(url)
data = response.json()
if data['cod'] != '404':
# Extract relevant information (this example uses a simplified approach)
disaster_type = "Flood" # For example purposes
risk_level = "High" if data['main']['temp'] > 300 else "Low"
risk_score = data['main']['temp'] # A placeholder for actual risk calculation
new_risk = NaturalDisasterRisk(
location=location,
disaster_type=disaster_type,
risk_level=risk_level,
description=f"Risk assessment for {disaster_type} in {location}",
risk_score=risk_score
)
db.session.add(new_risk)
db.session.commit()
# Initialize the database with disaster data
@app.before_first_request
def init_db():
db.create_all()
get_disaster_risk("New York") # Example: Adding a risk record for New York
if __name__ == '__main__':
app.run(debug=True)
Leave a Reply