homedocs/run.py

import os
import sys
import importlib.util
from flask import Flask, render_template
from app import create_app
from app.core.extensions import db
from app.core.models import Server, Subnet, App, Port
from app.core.auth import User  # Import User from auth module
from datetime import datetime
import random
import string
import json

# Add the current directory to Python path
current_dir = os.path.abspath(os.path.dirname(__file__))
sys.path.insert(0, current_dir)


def create_basic_app():
    """Create a Flask app without database dependencies"""
    app = Flask(
        __name__,
        template_folder=os.path.join(current_dir, "app", "templates"),
        static_folder=os.path.join(current_dir, "app", "static"),
    )

    # Basic configuration
    app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY", "dev-key-placeholder")
    app.config["DEBUG"] = True

    # Register basic routes
    register_routes(app)

    # Add a fallback index route if no routes match
    @app.route("/")
    def index():
        return "Your Network Management Flask Application is running! Navigate to /dashboard to see content."

    return app


def register_routes(app):
    """Register blueprints without database dependencies"""
    routes_dir = os.path.join(current_dir, "app", "routes")

    # Check if routes directory exists
    if not os.path.isdir(routes_dir):
        print(f"Warning: Routes directory {routes_dir} not found")
        return

    # Try to register API blueprint which is simplest
    try:
        from app.routes.api import bp as api_bp

        app.register_blueprint(api_bp)
        print("Registered API blueprint")
    except Exception as e:
        print(f"Could not register API blueprint: {e}")

    # Try to register other blueprints with basic error handling
    try:
        from app.routes.dashboard import bp as dashboard_bp

        app.register_blueprint(dashboard_bp)
        print("Registered dashboard blueprint")
    except ImportError as e:
        print(f"Could not import dashboard blueprint: {e}")

    try:
        from app.routes.ipam import bp as ipam_bp

        app.register_blueprint(ipam_bp)
        print("Registered IPAM blueprint")
    except ImportError as e:
        print(f"Could not import IPAM blueprint: {e}")


# Create a development application instance
print("Starting Flask app with SQLite database...")
app = create_app("development")


@app.shell_context_processor
def make_shell_context():
    return {
        "db": db,
        "User": User,
        "Server": Server,
        "Subnet": Subnet,
        "App": App,
        "Port": Port,
    }


def init_db():
    """Initialize database tables"""
    with app.app_context():
        db.create_all()


def create_admin_user():
    """Create an admin user if no users exist"""
    with app.app_context():
        if User.query.count() == 0:
            admin = User(username="admin", email="admin@example.com", is_admin=True)
            admin.set_password("admin")
            db.session.add(admin)
            db.session.commit()
            print("Created admin user: admin@example.com (password: admin)")


# Update seed_data to use consistent structures
def seed_data():
    """Add some sample data to the database"""
    with app.app_context():
        # Only seed if the database is empty
        if Subnet.query.count() == 0:
            # Create sample subnets
            subnet1 = Subnet(
                cidr="192.168.1.0/24", location="Office", active_hosts=json.dumps([])
            )
            subnet2 = Subnet(
                cidr="10.0.0.0/24", location="Datacenter", active_hosts=json.dumps([])
            )

            db.session.add_all([subnet1, subnet2])
            db.session.commit()

            # Create sample servers
            server1 = Server(
                hostname="web-server", ip_address="192.168.1.10", subnet=subnet1
            )
            server2 = Server(
                hostname="db-server", ip_address="192.168.1.11", subnet=subnet1
            )
            server3 = Server(
                hostname="app-server", ip_address="10.0.0.5", subnet=subnet2
            )

            db.session.add_all([server1, server2, server3])
            db.session.commit()

            # Create sample apps
            app1 = App(
                name="Website",
                server=server1,
                documentation="# Company Website\nRunning on Nginx/PHP",
            )
            app2 = App(
                name="PostgreSQL",
                server=server2,
                documentation="# Database Server\nPostgreSQL 15",
            )
            app3 = App(
                name="API Service",
                server=server3,
                documentation="# REST API\nNode.js service",
            )

            db.session.add_all([app1, app2, app3])
            db.session.commit()

            # Create sample ports
            port1 = Port(app=app1, port_number=80, protocol="TCP", description="HTTP")
            port2 = Port(app=app1, port_number=443, protocol="TCP", description="HTTPS")
            port3 = Port(
                app=app2, port_number=5432, protocol="TCP", description="PostgreSQL"
            )
            port4 = Port(
                app=app3, port_number=3000, protocol="TCP", description="Node.js API"
            )

            db.session.add_all([port1, port2, port3, port4])
            db.session.commit()

            print("Sample data has been added to the database")


if __name__ == "__main__":
    # Create the app first
    app = create_app()

    # Initialize database if needed
    if (
        not os.path.exists("app.db")
        and "sqlite" in app.config["SQLALCHEMY_DATABASE_URI"]
    ):
        print("Database not found, initializing...")
        try:
            init_db()

            # Uncomment to add sample data
            # create_admin_user()
            # seed_data()
        except Exception as e:
            print(f"Error initializing database: {e}")
            sys.exit(1)

    # Run the application
    try:
        app.run(debug=True, port=5001)
    except Exception as e:
        print(f"Error starting Flask app: {e}")
        sys.exit(1)