603 lines
20 KiB
Python
603 lines
20 KiB
Python
from flask import Blueprint, render_template, redirect, url_for, request, flash, jsonify
|
|
from flask_login import login_required, current_user
|
|
import markdown
|
|
from app.core.models import Server, App, Subnet, Port
|
|
from app.core.extensions import db, limiter
|
|
from datetime import datetime
|
|
from app.utils.app_utils import validate_app_data, is_port_in_use
|
|
|
|
bp = Blueprint("dashboard", __name__, url_prefix="/dashboard")
|
|
|
|
|
|
@bp.route("/")
|
|
def dashboard_home():
|
|
"""Main dashboard view showing server statistics"""
|
|
# Check if user is logged in, redirect if not
|
|
if not current_user.is_authenticated:
|
|
flash("Please log in to access this page.", "info")
|
|
return redirect(url_for('auth.login'))
|
|
|
|
server_count = Server.query.count()
|
|
app_count = App.query.count()
|
|
subnet_count = Subnet.query.count()
|
|
|
|
# Get latest added servers
|
|
latest_servers = Server.query.order_by(Server.created_at.desc()).limit(5).all()
|
|
|
|
# Get subnets with usage stats
|
|
subnets = Subnet.query.all()
|
|
for subnet in subnets:
|
|
subnet.usage_percent = (
|
|
subnet.used_ips / 254 * 100 if subnet.cidr.endswith("/24") else 0
|
|
)
|
|
|
|
return render_template(
|
|
"dashboard/index.html",
|
|
title="Dashboard",
|
|
server_count=server_count,
|
|
app_count=app_count,
|
|
subnet_count=subnet_count,
|
|
latest_servers=latest_servers,
|
|
subnets=subnets,
|
|
now=datetime.now(),
|
|
)
|
|
|
|
|
|
@bp.route("/servers")
|
|
@login_required
|
|
def server_list():
|
|
"""List all servers"""
|
|
servers = Server.query.order_by(Server.hostname).all()
|
|
|
|
return render_template(
|
|
"dashboard/server_list.html",
|
|
title="Servers",
|
|
servers=servers,
|
|
now=datetime.now(),
|
|
)
|
|
|
|
|
|
@bp.route("/server/<int:server_id>")
|
|
@login_required
|
|
def server_view(server_id):
|
|
"""View server details"""
|
|
server = Server.query.get_or_404(server_id)
|
|
apps = App.query.filter_by(server_id=server_id).all()
|
|
|
|
return render_template(
|
|
"dashboard/server_view.html",
|
|
title=f"Server - {server.hostname}",
|
|
server=server,
|
|
apps=apps,
|
|
now=datetime.now(),
|
|
)
|
|
|
|
|
|
@bp.route("/server/new", methods=["GET", "POST"])
|
|
@login_required
|
|
def server_new():
|
|
"""Create a new server"""
|
|
subnets = Subnet.query.all()
|
|
|
|
if request.method == "POST":
|
|
hostname = request.form.get("hostname")
|
|
ip_address = request.form.get("ip_address")
|
|
subnet_id = request.form.get("subnet_id")
|
|
documentation = request.form.get("documentation", "")
|
|
|
|
# Basic validation
|
|
if not hostname or not ip_address or not subnet_id:
|
|
flash("Please fill in all required fields", "danger")
|
|
return render_template(
|
|
"dashboard/server_form.html",
|
|
title="New Server",
|
|
subnets=subnets,
|
|
now=datetime.now(),
|
|
)
|
|
|
|
# Check if hostname or IP already exists
|
|
if Server.query.filter_by(hostname=hostname).first():
|
|
flash("Hostname already exists", "danger")
|
|
return render_template(
|
|
"dashboard/server_form.html",
|
|
title="New Server",
|
|
subnets=subnets,
|
|
now=datetime.now(),
|
|
)
|
|
|
|
if Server.query.filter_by(ip_address=ip_address).first():
|
|
flash("IP address already exists", "danger")
|
|
return render_template(
|
|
"dashboard/server_form.html",
|
|
title="New Server",
|
|
subnets=subnets,
|
|
now=datetime.now(),
|
|
)
|
|
|
|
# Create new server
|
|
server = Server(
|
|
hostname=hostname,
|
|
ip_address=ip_address,
|
|
subnet_id=subnet_id,
|
|
documentation=documentation,
|
|
)
|
|
|
|
db.session.add(server)
|
|
db.session.commit()
|
|
|
|
flash("Server created successfully", "success")
|
|
return redirect(url_for("dashboard.server_view", server_id=server.id))
|
|
|
|
return render_template(
|
|
"dashboard/server_form.html",
|
|
title="New Server",
|
|
subnets=subnets,
|
|
now=datetime.now(),
|
|
)
|
|
|
|
|
|
@bp.route("/server/<int:server_id>/edit", methods=["GET", "POST"])
|
|
@login_required
|
|
def server_edit(server_id):
|
|
"""Edit an existing server"""
|
|
server = Server.query.get_or_404(server_id)
|
|
subnets = Subnet.query.all()
|
|
|
|
if request.method == "POST":
|
|
hostname = request.form.get("hostname")
|
|
ip_address = request.form.get("ip_address")
|
|
subnet_id = request.form.get("subnet_id")
|
|
documentation = request.form.get("documentation", "")
|
|
|
|
if not hostname or not ip_address or not subnet_id:
|
|
flash("All fields are required", "danger")
|
|
return render_template(
|
|
"dashboard/server_form.html",
|
|
title="Edit Server",
|
|
server=server,
|
|
subnets=subnets,
|
|
)
|
|
|
|
# Check if hostname changed and already exists
|
|
if (
|
|
hostname != server.hostname
|
|
and Server.query.filter_by(hostname=hostname).first()
|
|
):
|
|
flash("Hostname already exists", "danger")
|
|
return render_template(
|
|
"dashboard/server_form.html",
|
|
title="Edit Server",
|
|
server=server,
|
|
subnets=subnets,
|
|
)
|
|
|
|
# Check if IP changed and already exists
|
|
if (
|
|
ip_address != server.ip_address
|
|
and Server.query.filter_by(ip_address=ip_address).first()
|
|
):
|
|
flash("IP address already exists", "danger")
|
|
return render_template(
|
|
"dashboard/server_form.html",
|
|
title="Edit Server",
|
|
server=server,
|
|
subnets=subnets,
|
|
)
|
|
|
|
# Update server
|
|
server.hostname = hostname
|
|
server.ip_address = ip_address
|
|
server.subnet_id = subnet_id
|
|
server.documentation = documentation
|
|
|
|
db.session.commit()
|
|
|
|
flash("Server updated successfully", "success")
|
|
return redirect(url_for("dashboard.server_view", server_id=server.id))
|
|
|
|
# GET request - show form with current values
|
|
return render_template(
|
|
"dashboard/server_form.html",
|
|
title=f"Edit Server - {server.hostname}",
|
|
server=server,
|
|
subnets=subnets,
|
|
)
|
|
|
|
|
|
@bp.route("/server/<int:server_id>/delete", methods=["POST"])
|
|
@login_required
|
|
def server_delete(server_id):
|
|
"""Delete a server"""
|
|
server = Server.query.get_or_404(server_id)
|
|
|
|
# Delete all apps associated with this server
|
|
App.query.filter_by(server_id=server_id).delete()
|
|
|
|
# Delete the server
|
|
db.session.delete(server)
|
|
db.session.commit()
|
|
|
|
flash("Server deleted successfully", "success")
|
|
return redirect(url_for("dashboard.dashboard_home"))
|
|
|
|
|
|
@bp.route("/app/new", methods=["GET", "POST"])
|
|
@bp.route("/app/new/<int:server_id>", methods=["GET", "POST"])
|
|
@login_required
|
|
def app_new(server_id=None):
|
|
"""Create a new application"""
|
|
servers = Server.query.all()
|
|
|
|
if request.method == "POST":
|
|
name = request.form.get("name", "").strip()
|
|
server_id = request.form.get("server_id")
|
|
documentation = request.form.get("documentation", "")
|
|
url = request.form.get("url", "")
|
|
|
|
# Validate application name
|
|
if not name:
|
|
flash("Application name is required", "danger")
|
|
return render_template(
|
|
"dashboard/app_form.html",
|
|
edit_mode=False,
|
|
servers=servers,
|
|
selected_server_id=server_id
|
|
)
|
|
|
|
# Check for duplicate application names on the same server
|
|
existing_app = App.query.filter_by(name=name, server_id=server_id).first()
|
|
if existing_app:
|
|
flash(f"An application with the name '{name}' already exists on this server", "danger")
|
|
return render_template(
|
|
"dashboard/app_form.html",
|
|
edit_mode=False,
|
|
servers=servers,
|
|
selected_server_id=server_id
|
|
)
|
|
|
|
# Process port data from form
|
|
port_data = []
|
|
port_numbers = request.form.getlist("port_numbers[]")
|
|
protocols = request.form.getlist("protocols[]")
|
|
descriptions = request.form.getlist("port_descriptions[]")
|
|
|
|
for i in range(len(port_numbers)):
|
|
if port_numbers[i] and port_numbers[i].strip():
|
|
protocol = protocols[i] if i < len(protocols) else "TCP"
|
|
description = descriptions[i] if i < len(descriptions) else ""
|
|
port_data.append((port_numbers[i], protocol, description))
|
|
|
|
# Check for port conflicts proactively
|
|
conflicts = []
|
|
seen_ports = set() # To track ports already seen in this submission
|
|
|
|
for i, (port_number, protocol, _) in enumerate(port_data):
|
|
try:
|
|
clean_port = int(port_number)
|
|
# Check if this port has already been seen in this submission
|
|
port_key = f"{clean_port}/{protocol}"
|
|
if port_key in seen_ports:
|
|
conflicts.append((clean_port, protocol, "Duplicate port in submission"))
|
|
continue
|
|
seen_ports.add(port_key)
|
|
|
|
# Check if the port is in use by another application
|
|
in_use, conflicting_app_name = is_port_in_use(
|
|
clean_port, protocol, server_id
|
|
)
|
|
|
|
if in_use:
|
|
conflicts.append((clean_port, protocol, f"Port {clean_port}/{protocol} is already in use by application '{conflicting_app_name}'"))
|
|
except (ValueError, TypeError):
|
|
continue
|
|
|
|
if conflicts:
|
|
for conflict in conflicts:
|
|
flash(f"Conflict: {conflict[0]}/{conflict[1]} - {conflict[2]}", "danger")
|
|
return render_template(
|
|
"dashboard/app_form.html",
|
|
edit_mode=False,
|
|
servers=servers,
|
|
selected_server_id=server_id
|
|
)
|
|
|
|
# Create the application
|
|
try:
|
|
new_app = App(
|
|
name=name,
|
|
server_id=server_id,
|
|
documentation=documentation,
|
|
url=url
|
|
)
|
|
db.session.add(new_app)
|
|
db.session.flush() # Get the app ID without committing
|
|
|
|
# Add ports
|
|
for port_number, protocol, description in port_data:
|
|
new_port = Port(
|
|
app_id=new_app.id,
|
|
port_number=int(port_number),
|
|
protocol=protocol,
|
|
description=description
|
|
)
|
|
db.session.add(new_port)
|
|
|
|
db.session.commit()
|
|
flash(f"Application '{name}' created successfully", "success")
|
|
return redirect(url_for("dashboard.app_view", app_id=new_app.id))
|
|
except Exception as e:
|
|
db.session.rollback()
|
|
flash(f"Error creating application: {str(e)}", "danger")
|
|
|
|
# GET request or validation failed - render the form
|
|
return render_template(
|
|
"dashboard/app_form.html",
|
|
edit_mode=False,
|
|
servers=servers,
|
|
selected_server_id=server_id
|
|
)
|
|
|
|
|
|
@bp.route("/app/<int:app_id>", methods=["GET"])
|
|
@login_required
|
|
def app_view(app_id):
|
|
"""View a specific application"""
|
|
app = App.query.get_or_404(app_id)
|
|
server = Server.query.get(app.server_id)
|
|
|
|
return render_template(
|
|
"dashboard/app_view.html",
|
|
title=f"Application - {app.name}",
|
|
app=app,
|
|
server=server,
|
|
now=datetime.now(),
|
|
)
|
|
|
|
|
|
@bp.route("/app/<int:app_id>/edit", methods=["GET", "POST"])
|
|
@login_required
|
|
def app_edit(app_id):
|
|
"""Edit an existing application with comprehensive error handling"""
|
|
app = App.query.get_or_404(app_id)
|
|
servers = Server.query.all()
|
|
|
|
if request.method == "POST":
|
|
# Get form data
|
|
name = request.form.get("name", "").strip()
|
|
server_id = request.form.get("server_id")
|
|
documentation = request.form.get("documentation", "")
|
|
url = request.form.get("url", "") # Get the URL
|
|
|
|
# Validate application name
|
|
if not name:
|
|
flash("Application name is required", "danger")
|
|
return render_template(
|
|
"dashboard/app_form.html",
|
|
edit_mode=True,
|
|
app=app,
|
|
servers=servers
|
|
)
|
|
|
|
# Check for duplicate application names on the same server (excluding this app)
|
|
existing_app = App.query.filter(
|
|
App.name == name,
|
|
App.server_id == server_id,
|
|
App.id != app_id
|
|
).first()
|
|
|
|
if existing_app:
|
|
flash(f"An application with the name '{name}' already exists on this server", "danger")
|
|
return render_template(
|
|
"dashboard/app_form.html",
|
|
edit_mode=True,
|
|
app=app,
|
|
servers=servers
|
|
)
|
|
|
|
# Process port data from form
|
|
port_data = []
|
|
port_numbers = request.form.getlist("port_numbers[]")
|
|
protocols = request.form.getlist("protocols[]")
|
|
descriptions = request.form.getlist("port_descriptions[]")
|
|
|
|
for i in range(len(port_numbers)):
|
|
if port_numbers[i] and port_numbers[i].strip():
|
|
protocol = protocols[i] if i < len(protocols) else "TCP"
|
|
description = descriptions[i] if i < len(descriptions) else ""
|
|
port_data.append((port_numbers[i], protocol, description))
|
|
|
|
# Check for port conflicts proactively
|
|
conflicts = []
|
|
seen_ports = set() # To track ports already seen in this submission
|
|
|
|
for i, (port_number, protocol, _) in enumerate(port_data):
|
|
try:
|
|
clean_port = int(port_number)
|
|
# Check if this port has already been seen in this submission
|
|
port_key = f"{clean_port}/{protocol}"
|
|
if port_key in seen_ports:
|
|
conflicts.append((clean_port, protocol, "Duplicate port in submission"))
|
|
continue
|
|
seen_ports.add(port_key)
|
|
|
|
# Check if the port is in use by another application
|
|
in_use, conflicting_app_name = is_port_in_use(
|
|
clean_port, protocol, server_id, exclude_app_id=app_id
|
|
)
|
|
|
|
if in_use:
|
|
conflicts.append((clean_port, protocol, f"Port {clean_port}/{protocol} is already in use by application '{conflicting_app_name}'"))
|
|
except (ValueError, TypeError):
|
|
continue
|
|
|
|
if conflicts:
|
|
for conflict in conflicts:
|
|
flash(f"Conflict: {conflict[0]}/{conflict[1]} - {conflict[2]}", "danger")
|
|
return render_template(
|
|
"dashboard/app_form.html",
|
|
edit_mode=True,
|
|
app=app,
|
|
servers=servers
|
|
)
|
|
|
|
# Update application details
|
|
app.name = name
|
|
app.server_id = server_id
|
|
app.documentation = documentation
|
|
app.url = url
|
|
|
|
# Only delete existing ports if new port data is provided
|
|
if port_data:
|
|
# Remove existing ports and add new ones
|
|
Port.query.filter_by(app_id=app_id).delete()
|
|
for port_number, protocol, description in port_data:
|
|
new_port = Port(
|
|
app_id=app_id,
|
|
port_number=int(port_number),
|
|
protocol=protocol,
|
|
description=description
|
|
)
|
|
db.session.add(new_port)
|
|
|
|
db.session.commit()
|
|
flash("Application updated successfully", "success")
|
|
return redirect(url_for("dashboard.app_view", app_id=app_id))
|
|
|
|
return render_template(
|
|
"dashboard/app_form.html",
|
|
edit_mode=True,
|
|
app=app,
|
|
servers=servers
|
|
)
|
|
|
|
|
|
@bp.route("/app/<int:app_id>/delete", methods=["POST"])
|
|
@login_required
|
|
def app_delete(app_id):
|
|
"""Delete an application and all its ports"""
|
|
app = App.query.get_or_404(app_id)
|
|
app_name = app.name
|
|
server_id = app.server_id
|
|
|
|
try:
|
|
# First explicitly delete all associated ports
|
|
Port.query.filter_by(app_id=app_id).delete()
|
|
|
|
# Then delete the application
|
|
db.session.delete(app)
|
|
db.session.commit()
|
|
|
|
flash(f"Application '{app_name}' has been deleted", "success")
|
|
|
|
# Redirect back to server view
|
|
return redirect(url_for("dashboard.server_view", server_id=server_id))
|
|
except Exception as e:
|
|
db.session.rollback()
|
|
flash(f"Error deleting application: {str(e)}", "danger")
|
|
return redirect(url_for("dashboard.app_view", app_id=app_id))
|
|
|
|
|
|
@bp.route("/settings", methods=["GET", "POST"])
|
|
@login_required
|
|
def settings():
|
|
"""User settings page"""
|
|
if request.method == "POST":
|
|
# Handle user settings update
|
|
current_password = request.form.get("current_password")
|
|
new_password = request.form.get("new_password")
|
|
confirm_password = request.form.get("confirm_password")
|
|
|
|
# Validate inputs
|
|
if not current_password:
|
|
flash("Current password is required", "danger")
|
|
return redirect(url_for("dashboard.settings"))
|
|
|
|
if new_password != confirm_password:
|
|
flash("New passwords do not match", "danger")
|
|
return redirect(url_for("dashboard.settings"))
|
|
|
|
# Verify current password
|
|
if not current_user.check_password(current_password):
|
|
flash("Current password is incorrect", "danger")
|
|
return redirect(url_for("dashboard.settings"))
|
|
|
|
# Update password
|
|
current_user.set_password(new_password)
|
|
db.session.commit()
|
|
|
|
flash("Password updated successfully", "success")
|
|
return redirect(url_for("dashboard.settings"))
|
|
|
|
return render_template("dashboard/settings.html", title="User Settings")
|
|
|
|
|
|
@bp.route("/overview")
|
|
@login_required
|
|
def overview():
|
|
"""Hierarchical overview of subnets, servers, and applications"""
|
|
# Get all subnets with their servers
|
|
subnets = Subnet.query.all()
|
|
|
|
# Get servers without subnets
|
|
standalone_servers = Server.query.filter(Server.subnet_id.is_(None)).all()
|
|
|
|
# Create a hierarchical structure
|
|
hierarchy = {
|
|
'subnets': [],
|
|
'standalone_servers': []
|
|
}
|
|
|
|
# Organize subnets and their servers
|
|
for subnet in subnets:
|
|
subnet_data = {
|
|
'id': subnet.id,
|
|
'cidr': subnet.cidr,
|
|
'description': subnet.description,
|
|
'location': subnet.location,
|
|
'servers': []
|
|
}
|
|
|
|
for server in subnet.servers:
|
|
server_data = {
|
|
'id': server.id,
|
|
'hostname': server.hostname,
|
|
'ip_address': server.ip_address,
|
|
'apps': []
|
|
}
|
|
|
|
for app in server.apps:
|
|
app_data = {
|
|
'id': app.id,
|
|
'name': app.name,
|
|
'ports': app.ports
|
|
}
|
|
server_data['apps'].append(app_data)
|
|
|
|
subnet_data['servers'].append(server_data)
|
|
|
|
hierarchy['subnets'].append(subnet_data)
|
|
|
|
# Organize standalone servers
|
|
for server in standalone_servers:
|
|
server_data = {
|
|
'id': server.id,
|
|
'hostname': server.hostname,
|
|
'ip_address': server.ip_address,
|
|
'apps': []
|
|
}
|
|
|
|
for app in server.apps:
|
|
app_data = {
|
|
'id': app.id,
|
|
'name': app.name,
|
|
'ports': app.ports
|
|
}
|
|
server_data['apps'].append(app_data)
|
|
|
|
hierarchy['standalone_servers'].append(server_data)
|
|
|
|
return render_template(
|
|
"dashboard/overview.html",
|
|
title="Infrastructure Overview",
|
|
hierarchy=hierarchy
|
|
)
|