generated from hjess/PythonTemplateProject
Henrik Jess Nielsen
379f6a4273
All checks were successful
Build, Push, and Deploy to Nomad / docker-nomad (push) Successful in 34s
101 lines
4.0 KiB
Python
101 lines
4.0 KiB
Python
from fastapi import FastAPI, Request
|
|
from fastapi.staticfiles import StaticFiles
|
|
from fastapi.templating import Jinja2Templates
|
|
from fastapi.responses import HTMLResponse
|
|
from contextlib import asynccontextmanager
|
|
import json
|
|
import os
|
|
from markdown_render import render_markdown_with_jinja
|
|
|
|
|
|
class App:
|
|
def __init__(self):
|
|
"""Initialize the FastAPI app."""
|
|
self.app = FastAPI(lifespan=self.lifespan)
|
|
self.templates = Jinja2Templates(directory="templates")
|
|
self.data = self.load_mock_data()
|
|
|
|
# Mount directories
|
|
self.app.mount("/data", StaticFiles(directory="data"), name="data")
|
|
self.app.mount("/static", StaticFiles(directory="static"), name="static")
|
|
|
|
# Add routes
|
|
self.add_routes()
|
|
|
|
# 1. Lifespan events
|
|
@asynccontextmanager
|
|
async def lifespan(self, app: FastAPI):
|
|
print("App startup: Processing Markdown files...")
|
|
self.process_markdown_files("./data", "./data") # Process all Markdown files
|
|
print("Markdown processing complete!")
|
|
yield # Allow the app to start
|
|
print("App shutdown: Cleanup complete.")
|
|
|
|
# 2. Load JSON data
|
|
def load_mock_data(self):
|
|
"""Load mock data from a JSON file."""
|
|
with open("mock_data.json") as file:
|
|
return json.load(file)
|
|
|
|
# 3. Markdown processing logic
|
|
@staticmethod
|
|
def process_markdown_files(input_dir: str, output_dir: str):
|
|
"""
|
|
Recursively process all Markdown files in the input directory,
|
|
render them to HTML, and save them in the output directory.
|
|
"""
|
|
for root, _, files in os.walk(input_dir):
|
|
for file in files:
|
|
if file.endswith(".md"):
|
|
input_file_path = os.path.join(root, file)
|
|
relative_path = os.path.relpath(input_file_path, input_dir)
|
|
output_file_path = os.path.join(output_dir, os.path.splitext(relative_path)[0] + ".html")
|
|
|
|
os.makedirs(os.path.dirname(output_file_path), exist_ok=True)
|
|
|
|
with open(input_file_path, "r", encoding="utf-8") as md_file:
|
|
markdown_content = md_file.read()
|
|
|
|
print(f"Processing: {input_file_path} -> {output_file_path}")
|
|
rendered_html = render_markdown_with_jinja(markdown_content)
|
|
|
|
with open(output_file_path, "w", encoding="utf-8") as html_file:
|
|
html_file.write(rendered_html)
|
|
|
|
# 4. Routes
|
|
def add_routes(self):
|
|
"""Add all routes to the FastAPI app."""
|
|
@self.app.get("/", response_class=HTMLResponse)
|
|
async def get_index(request: Request):
|
|
"""Index route."""
|
|
return self.templates.TemplateResponse(
|
|
"index.html",
|
|
{"request": request, "data": self.data, "page_title": "Forside", "author": "Henrik"},
|
|
)
|
|
|
|
@self.app.get("/category/{category_name}", response_class=HTMLResponse)
|
|
async def get_category(request: Request, category_name: str):
|
|
"""Category route."""
|
|
category = next((cat for cat in self.data["categories"] if cat["path"] == category_name), None)
|
|
if category:
|
|
category_file = f"data/{category_name}/index.html"
|
|
if os.path.exists(category_file):
|
|
with open(category_file) as file:
|
|
category_content = file.read()
|
|
return self.templates.TemplateResponse(
|
|
"category.html",
|
|
{
|
|
"request": request,
|
|
"data": self.data,
|
|
"page_title": category["name"],
|
|
"author": category["author"],
|
|
"content": category_content,
|
|
},
|
|
)
|
|
return HTMLResponse("Kategori ikke fundet", status_code=404)
|
|
|
|
|
|
# Create the app instance
|
|
app_instance = App()
|
|
app = app_instance.app
|