My Blog

Natural Disaster Risk Management and Insurance

—

by

tayyaba
in

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)

Comments

Leave a Reply

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