My Blog

My WordPress Blog

My Blog

My WordPress Blog

Natural Disaster Risk Management and Insurance

By saqibkhanPosted on Posted in ProjectNo Comments on Natural Disaster Risk Management and Insurance

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&#91;'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&#91;'claim_amount'])
    description = request.form&#91;'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}&amp;appid={api_key}'
response = requests.get(url)
data = response.json()


if data&#91;'cod'] != '404':
    # Extract relevant information (this example uses a simplified approach)
    disaster_type = "Flood"  # For example purposes
    risk_level = "High" if data&#91;'main']&#91;'temp'] &gt; 300 else "Low"
    risk_score = data&#91;'main']&#91;'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)</code></code></pre>
Natural Disaster Risk Management and Insurance

Leave a Reply

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

Scroll to top